moab::WriteNC Class Reference

Export NC files. More...

#include <WriteNC.hpp>

Inheritance diagram for moab::WriteNC:

Collaboration diagram for moab::WriteNC:

Classes
class	AttData
class	VarData

Public Member Functions
	WriteNC (Interface *impl=NULL)
	Constructor. More...
virtual	~WriteNC ()
	Destructor. More...
ErrorCode	write_file (const char *file_name, const bool overwrite, const FileOptions &opts, const EntityHandle *output_list, const int num_sets, const std::vector< std::string > &qa_list, const Tag *tag_list=NULL, int num_tags=0, int export_dimension=3)
	Writes out a file. More...
Public Member Functions inherited from moab::WriterIface
virtual	~WriterIface ()

Static Public Member Functions
static WriterIface *	factory (Interface *)
	Factory method. More...

Private Types
enum	EntityLocation {   ENTLOCVERT = 0 , ENTLOCNSEDGE , ENTLOCEWEDGE , ENTLOCFACE ,   ENTLOCSET , ENTLOCEDGE , ENTLOCREGION }
	ENTLOCNSEDGE for north/south edge ENTLOCWEEDGE for west/east edge. More...

Private Member Functions
ErrorCode	parse_options (const FileOptions &opts, std::vector< std::string > &var_names, std::vector< std::string > &desired_names, std::vector< int > &tstep_nums, std::vector< double > &tstep_vals)
ErrorCode	process_conventional_tags (EntityHandle fileSet)
ErrorCode	process_concatenated_attribute (const void *attPtr, int attSz, std::vector< int > &attLen, std::map< std::string, AttData > &attributes)

Private Attributes
std::vector< std::string >	dimNames
	This info will be reconstructed from metadata stored on conventional fileSet tags Dimension names. More...
std::vector< int >	dimLens
	Dimension lengths. More...
std::set< std::string >	usedCoordinates
	Will collect used dimensions (coordinate variables) More...
std::set< std::string >	dummyVarNames
	Dummy variables (for dimensions that have no corresponding coordinate variables) More...
std::map< std::string, AttData >	globalAtts
	Global attribs. More...
std::map< std::string, VarData >	varInfo
	Variable info. More...
Interface *	mbImpl
	Interface instance. More...
WriteUtilIface *	mWriteIface
const char *	fileName
	File var. More...
int	fileId
	File numbers assigned by (p)netcdf. More...
DebugOutput	dbgOut
	Debug stuff. More...
bool	noMesh
	Write options. More...
bool	noVars
bool	append
Tag	mGlobalIdTag
	Cached tags for writing. This will be important for ordering the data, in parallel. More...
bool	isParallel
	Are we writing in parallel? (probably in the future) More...
std::string	grid_type
	CAM Euler, etc,. More...
NCWriteHelper *	myHelper
	Helper class instance. More...

Friends
class	NCWriteHelper
class	ScdNCWriteHelper
class	UcdNCWriteHelper
class	NCWriteEuler
class	NCWriteFV
class	NCWriteHOMME
class	NCWriteMPAS
class	NCWriteGCRM
class	NCWriteScrip
class	NCWriteESMF
class	NCWriteDomain

Detailed Description

Export NC files.

Definition at line 71 of file WriteNC.hpp.

Member Enumeration Documentation

EntityLocation

enum moab::WriteNC::EntityLocation

private

ENTLOCNSEDGE for north/south edge ENTLOCWEEDGE for west/east edge.

Enumerator
ENTLOCVERT
ENTLOCNSEDGE
ENTLOCEWEDGE
ENTLOCFACE
ENTLOCSET
ENTLOCEDGE
ENTLOCREGION

Definition at line 109 of file WriteNC.hpp.

    {
        ENTLOCVERT = 0,
        ENTLOCNSEDGE,
        ENTLOCEWEDGE,
        ENTLOCFACE,
        ENTLOCSET,
        ENTLOCEDGE,
        ENTLOCREGION
    };

Constructor & Destructor Documentation

WriteNC()

moab::WriteNC::WriteNC ( Interface *  impl = NULL )

explicit

Constructor.

Definition at line 32 of file WriteNC.cpp.

    : mbImpl( impl ), dbgOut( stderr ),
#ifdef MOAB_HAVE_MPI
      myPcomm( NULL ),
#endif
      noMesh( false ), noVars( false ), append( false ), mGlobalIdTag( 0 ), isParallel( false ), myHelper( NULL )
{
    assert( impl != NULL );
    impl->query_interface( mWriteIface );
}

References mWriteIface, and moab::Interface::query_interface().

Referenced by factory().

~WriteNC()

moab::WriteNC::~WriteNC ( )

virtual

Destructor.

Definition at line 43 of file WriteNC.cpp.

{
    mbImpl->release_interface( mWriteIface );
    if( myHelper != NULL ) delete myHelper;
}

References mbImpl, mWriteIface, myHelper, and moab::Interface::release_interface().

Member Function Documentation

factory()

WriterIface * moab::WriteNC::factory ( Interface *  iface )

static

Factory method.

Definition at line 27 of file WriteNC.cpp.

{
    return new WriteNC( iface );
}

References iface, and WriteNC().

Referenced by moab::ReaderWriterSet::ReaderWriterSet().

parse_options()

ErrorCode moab::WriteNC::parse_options ( const FileOptions &  opts, std::vector< std::string > &  var_names, std::vector< std::string > &  desired_names, std::vector< int > &  tstep_nums, std::vector< double > &  tstep_vals  )

private

Definition at line 206 of file WriteNC.cpp.

{
    int tmpval;
    if( MB_SUCCESS == opts.get_int_option( "DEBUG_IO", 1, tmpval ) )
    {
        dbgOut.set_verbosity( tmpval );
        dbgOut.set_prefix( "NCWrite" );
    }
 
    ErrorCode rval = opts.get_strs_option( "VARIABLE", var_names );
    if( MB_TYPE_OUT_OF_RANGE == rval )
        noVars = true;
    else
        noVars = false;
 
    rval = opts.get_strs_option( "RENAME", desired_names );
    if( MB_ENTITY_NOT_FOUND == rval )
    {
        if( !noVars )
        {
            desired_names.resize( var_names.size() );
            std::copy( var_names.begin(), var_names.end(), desired_names.begin() );
        }
    }
    // Either way
    assert( desired_names.size() == var_names.size() );
 
    opts.get_ints_option( "TIMESTEP", tstep_nums );
    opts.get_reals_option( "TIMEVAL", tstep_vals );
    rval = opts.get_null_option( "NOMESH" );
    if( MB_SUCCESS == rval ) noMesh = true;
 
    rval = opts.get_null_option( "APPEND" );
    if( MB_SUCCESS == rval ) append = true;
 
    // WRITE_FORMAT: optional explicit output grid_type. Set this when you
    // want to convert FROM one grid type TO another (e.g. MPAS → SCRIP),
    // or when writing from a mesh that doesn't carry the climate
    // __MESH_TYPE / __VAR_NAMES tags that process_conventional_tags
    // expects. Valid values match the strings returned by the readers'
    // get_mesh_type_name(): "CAM_EUL", "CAM_FV", "CAM_SE", "MPAS",
    // "GCRM", "SCRIP", "ESMF", "DOMAIN".
    std::string requestedFormat;
    rval = opts.get_str_option( "WRITE_FORMAT", requestedFormat );
    if( MB_SUCCESS == rval && !requestedFormat.empty() )
    {
        grid_type = requestedFormat;
        dbgOut.tprintf( 1, "WRITE_FORMAT override: grid_type = %s\n", grid_type.c_str() );
    }
 
    if( 2 <= dbgOut.get_verbosity() )
    {
        if( !var_names.empty() )
        {
            std::cerr << "Variables requested: ";
            for( unsigned int i = 0; i < var_names.size(); i++ )
                std::cerr << var_names[i];
            std::cerr << std::endl;
        }
        if( !tstep_nums.empty() )
        {
            std::cerr << "Timesteps requested: ";
            for( unsigned int i = 0; i < tstep_nums.size(); i++ )
                std::cerr << tstep_nums[i];
            std::cerr << std::endl;
        }
        if( !tstep_vals.empty() )
        {
            std::cerr << "Time vals requested: ";
            for( unsigned int i = 0; i < tstep_vals.size(); i++ )
                std::cerr << tstep_vals[i];
            std::cerr << std::endl;
        }
    }
 
// FIXME: copied from ReadNC, may need revise
#ifdef MOAB_HAVE_MPI
    isParallel = ( opts.match_option( "PARALLEL", "WRITE_PART" ) != MB_ENTITY_NOT_FOUND );
 
    if( !isParallel )
        // Return success here, since rval still has _NOT_FOUND from not finding option
        // in this case, myPcomm will be NULL, so it can never be used; always check for isParallel
        // before any use for myPcomm
        return MB_SUCCESS;
 
    int pcomm_no = 0;
    rval         = opts.get_int_option( "PARALLEL_COMM", pcomm_no );
    if( MB_TYPE_OUT_OF_RANGE == rval )
    {
        MB_SET_ERR( rval, "Invalid value for PARALLEL_COMM option" );
    }
 
    myPcomm = ParallelComm::get_pcomm( mbImpl, pcomm_no );
    if( 0 == myPcomm )
    {
        myPcomm = new ParallelComm( mbImpl, MPI_COMM_WORLD );
    }
 
#ifndef MOAB_HAVE_PNETCDF
    const int procs = myPcomm->proc_config().proc_size();
    if( procs > 1 )
    {
        MB_SET_ERR( MB_UNSUPPORTED_OPERATION, "Attempt to launch NC writer in parallel without pnetcdf support" );
    }
#endif
 
    const int rank = myPcomm->proc_config().proc_rank();
    dbgOut.set_rank( rank );
#endif
 
    return MB_SUCCESS;
}

References append, dbgOut, ErrorCode, moab::FileOptions::get_int_option(), moab::FileOptions::get_ints_option(), moab::FileOptions::get_null_option(), moab::ParallelComm::get_pcomm(), moab::FileOptions::get_reals_option(), moab::FileOptions::get_str_option(), moab::FileOptions::get_strs_option(), moab::DebugOutput::get_verbosity(), grid_type, isParallel, moab::FileOptions::match_option(), MB_ENTITY_NOT_FOUND, MB_SET_ERR, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MB_UNSUPPORTED_OPERATION, mbImpl, noMesh, noVars, moab::DebugOutput::set_prefix(), moab::DebugOutput::set_rank(), moab::DebugOutput::set_verbosity(), and moab::DebugOutput::tprintf().

Referenced by write_file().

process_concatenated_attribute()

ErrorCode moab::WriteNC::process_concatenated_attribute ( const void *  attPtr, int  attSz, std::vector< int > &  attLen, std::map< std::string, AttData > &  attributes  )

private

Definition at line 566 of file WriteNC.cpp.

{
    std::size_t start       = 0;
    std::size_t att_counter = 0;
    std::string concatString( (char*)attPtr, (char*)attPtr + attSz );
 
    for( std::size_t i = 0; i != (size_t)attSz; i++ )
    {
        if( concatString[i] == '\0' )
        {
            std::string att_name( &concatString[start], i - start );
            start = i + 1;
            while( concatString[i] != ';' )
                ++i;
            std::string data_type( &concatString[start], i - start );
            ++i;
            start = i;
            i     = attLen[att_counter];
            if( concatString[i] != ';' ) MB_SET_ERR( MB_FAILURE, "Error parsing attributes" );
 
            std::string data_val( &concatString[start], i - start );
            start = i + 1;
 
            AttData& attrib = attributes[att_name];
            attrib.attValue = data_val;
            attrib.attLen   = data_val.size();
 
            if( data_type == "char" )
                attrib.attDataType = NC_CHAR;
            else if( data_type == "double" )
                attrib.attDataType = NC_DOUBLE;
            else if( data_type == "float" )
                attrib.attDataType = NC_FLOAT;
            else if( data_type == "int" )
                attrib.attDataType = NC_INT;
            else if( data_type == "short" )
                attrib.attDataType = NC_SHORT;
 
            ++att_counter;
            dbgOut.tprintf( 2, "       Process attribute %s with value %s \n", att_name.c_str(), data_val.c_str() );
        }
    }
 
    return MB_SUCCESS;
}

References moab::WriteNC::AttData::attDataType, moab::WriteNC::AttData::attLen, moab::WriteNC::AttData::attValue, dbgOut, MB_SET_ERR, MB_SUCCESS, and moab::DebugOutput::tprintf().

Referenced by process_conventional_tags().

process_conventional_tags()

ErrorCode moab::WriteNC::process_conventional_tags ( EntityHandle  fileSet )

private

Definition at line 325 of file WriteNC.cpp.

{
    ErrorCode rval;
 
    // Start copy
    Tag dimNamesTag      = 0;
    std::string tag_name = "__DIM_NAMES";
    const void* data     = NULL;
    int dimNamesSz       = 0;
    MB_CHK_SET_ERR( mbImpl->tag_get_handle( tag_name.c_str(), 0, MB_TYPE_OPAQUE, dimNamesTag, MB_TAG_ANY ),
                    "Trouble getting conventional tag " << tag_name );
    MB_CHK_SET_ERR( mbImpl->tag_get_by_ptr( dimNamesTag, &fileSet, 1, &data, &dimNamesSz ),
                    "Trouble getting data of conventional tag " << tag_name );
    const char* p = static_cast< const char* >( data );
    dbgOut.tprintf( 1, "__DIM_NAMES tag has string length %d\n", dimNamesSz );
 
    std::size_t start = 0;
 
    Tag dimLensTag = 0;
    tag_name       = "__DIM_LENS";
    data           = NULL;
    int dimLensSz  = 0;
    MB_CHK_SET_ERR( mbImpl->tag_get_handle( tag_name.c_str(), 0, MB_TYPE_INTEGER, dimLensTag, MB_TAG_ANY ),
                    "Trouble getting conventional tag " << tag_name );
    MB_CHK_SET_ERR( mbImpl->tag_get_by_ptr( dimLensTag, &fileSet, 1, &data, &dimLensSz ),
                    "Trouble getting data of conventional tag " << tag_name );
    const int* int_p = static_cast< const int* >( data );
    dbgOut.tprintf( 1, "__DIM_LENS tag has %d values\n", dimLensSz );
 
    int idxDim = 0;
    // Dim names are separated by '\0' in the string of __DIM_NAMES tag
    for( std::size_t i = 0; i != static_cast< std::size_t >( dimNamesSz ); i++ )
    {
        if( p[i] == '\0' )
        {
            std::string dim_name( &p[start], i - start );
            int len = int_p[idxDim];
            dimNames.push_back( dim_name );
            dimLens.push_back( len );
            dbgOut.tprintf( 2, "Dimension %s has length %d\n", dim_name.c_str(), len );
            // FIXME: Need info from moab to set unlimited dimension
            // Currently assume each file has the same number of time dimensions
            /*if ((dim_name == "time") || (dim_name == "Time"))
              insert(dim_name, *(new pcdim(dim_name, len * m_file_names.size(), true)));
            else
              insert(dim_name, *(new pcdim(dim_name, len)));*/
            start = i + 1;
            idxDim++;
        }
    }
 
    Tag meshTypeTag = 0;
    tag_name        = "__MESH_TYPE";
    data            = NULL;
    int meshTypeSz  = 0;
    MB_CHK_SET_ERR( mbImpl->tag_get_handle( tag_name.c_str(), 0, MB_TYPE_OPAQUE, meshTypeTag, MB_TAG_ANY ),
                    "Trouble getting conventional tag " << tag_name );
    MB_CHK_SET_ERR( mbImpl->tag_get_by_ptr( meshTypeTag, &fileSet, 1, &data, &meshTypeSz ),
                    "Trouble getting data of conventional tag " << tag_name );
    p         = static_cast< const char* >( data );
    grid_type = std::string( &p[0], meshTypeSz );
    dbgOut.tprintf( 2, "Mesh type: %s\n", grid_type.c_str() );
 
    // Read <__VAR_NAMES_LOCATIONS> tag
    Tag varNamesLocsTag = 0;
    tag_name            = "__VAR_NAMES_LOCATIONS";
    data                = NULL;
    int varNamesLocsSz  = 0;
    MB_CHK_SET_ERR( mbImpl->tag_get_handle( tag_name.c_str(), 0, MB_TYPE_INTEGER, varNamesLocsTag, MB_TAG_ANY ),
                    "Trouble getting conventional tag " << tag_name );
    MB_CHK_SET_ERR( mbImpl->tag_get_by_ptr( varNamesLocsTag, &fileSet, 1, &data, &varNamesLocsSz ),
                    "Trouble getting data of conventional tag " << tag_name );
    int_p = static_cast< const int* >( data );
    std::vector< int > varNamesLocs( varNamesLocsSz );
    std::copy( int_p, int_p + varNamesLocsSz, varNamesLocs.begin() );
 
    Tag varNamesTag = 0;
    tag_name        = "__VAR_NAMES";
    MB_CHK_SET_ERR( mbImpl->tag_get_handle( tag_name.c_str(), 0, MB_TYPE_OPAQUE, varNamesTag, MB_TAG_ANY ),
                    "Trouble getting conventional tag " << tag_name );
    data           = NULL;
    int varNamesSz = 0;
    MB_CHK_SET_ERR( mbImpl->tag_get_by_ptr( varNamesTag, &fileSet, 1, &data, &varNamesSz ),
                    "Trouble getting data of conventional tag " << tag_name );
    dbgOut.tprintf( 2, "__VAR_NAMES tag has string length %d\n", varNamesSz );
    p = static_cast< const char* >( data );
 
    start      = 0;
    int idxVar = 0;
    int sz;
    // Var names are separated by '\0' in the string of __VAR_NAMES tag
    for( std::size_t i = 0; i != static_cast< std::size_t >( varNamesSz ); i++ )
    {
        if( p[i] == '\0' )
        {
            std::string var_name( &p[start], i - start );
 
            dbgOut.tprintf( 2, "var name: %s index %d \n", var_name.c_str(), idxVar );
            // Process var name:
            // This will create/initiate map; we will populate variableDataStruct with info about
            // dims, tags, etc reference & is important; otherwise variableDataStruct will go out of
            // scope, and deleted :(
            VarData& variableDataStruct = varInfo[var_name];
            variableDataStruct.varName  = var_name;
            variableDataStruct.entLoc   = varNamesLocs[idxVar];
 
            dbgOut.tprintf( 2, "at var name %s varInfo size %d \n", var_name.c_str(), (int)varInfo.size() );
 
            sz                    = 0;
            Tag dims_tag          = 0;
            std::string dim_names = "__" + var_name + "_DIMS";
            rval = mbImpl->tag_get_handle( dim_names.c_str(), 0, MB_TYPE_OPAQUE, dims_tag, MB_TAG_ANY );
            if( MB_SUCCESS != rval )
            {
                if( MB_TAG_NOT_FOUND == rval )
                {
                    dbgOut.tprintf( 2, "tag : %s not found, continue \n", dim_names.c_str() );
                    start = i + 1;
                    idxVar++;
                    continue;
                }
                MB_SET_ERR( rval, "Trouble getting conventional tag " << dim_names );
            }
            MB_CHK_SET_ERR( mbImpl->tag_get_length( dims_tag, sz ),
                            "Trouble getting size of dimensions for variable " << var_name );
            sz /= sizeof( Tag );  // The type is MB_TYPE_OPAQUE, but it is a list of tags, so we
                                  // need to divide by the size of Tag
            // sz is used for number of dimension tags in this list
            dbgOut.tprintf( 2, "var name: %s has %d dimensions \n", var_name.c_str(), sz );
 
            variableDataStruct.varDims.resize( sz );
            const void* ptr = NULL;
            MB_CHK_SET_ERR( mbImpl->tag_get_by_ptr( dims_tag, &fileSet, 1, &ptr ),
                            "Could not get tag by pointer" );
 
            const Tag* ptags = static_cast< const moab::Tag* >( ptr );
            for( std::size_t j = 0; j != static_cast< std::size_t >( sz ); j++ )
            {
                std::string dim_name;
                MB_CHK_SET_ERR( mbImpl->tag_get_name( ptags[j], dim_name ),
                                "Trouble getting dimension of variable " << var_name );
                dbgOut.tprintf( 2, "var name: %s has %s as dimension \n", var_name.c_str(), dim_name.c_str() );
                std::vector< std::string >::iterator vit = std::find( dimNames.begin(), dimNames.end(), dim_name );
                if( vit == dimNames.end() )
                    MB_SET_ERR( MB_FAILURE, "Dimension " << dim_name << " not found for variable " << var_name );
                variableDataStruct.varDims[j] = (int)( vit - dimNames.begin() );  // Will be used for writing
                // This will have to change to actual file dimension, for writing
            }
 
            // Attributes for this variable
            std::stringstream ssTagName;
            ssTagName << "__" << var_name << "_ATTRIBS";
            tag_name      = ssTagName.str();
            Tag varAttTag = 0;
            MB_CHK_SET_ERR( mbImpl->tag_get_handle( tag_name.c_str(), 0, MB_TYPE_OPAQUE, varAttTag,
                                                    MB_TAG_SPARSE | MB_TAG_VARLEN ),
                            "Trouble getting conventional tag " << tag_name );
            const void* varAttPtr = NULL;
            int varAttSz          = 0;
            MB_CHK_SET_ERR( mbImpl->tag_get_by_ptr( varAttTag, &fileSet, 1, &varAttPtr, &varAttSz ),
                            "Trouble getting data of conventional tag " << tag_name );
            dbgOut.tprintf( 2, "Tag retrieved for variable %s\n", tag_name.c_str() );
 
            std::string attribString( (char*)varAttPtr, (char*)varAttPtr + varAttSz );
            if( attribString == "NO_ATTRIBS" )
            {
                // This variable has no attributes
                variableDataStruct.numAtts = 0;
            }
            else if( attribString == "DUMMY_VAR" )
            {
                // This variable is a dummy coordinate variable
                variableDataStruct.numAtts = 0;
                dummyVarNames.insert( variableDataStruct.varName );
            }
            else
            {
                ssTagName << "_LEN";
                tag_name         = ssTagName.str();
                Tag varAttLenTag = 0;
                MB_CHK_SET_ERR( mbImpl->tag_get_handle( tag_name.c_str(), 0, MB_TYPE_INTEGER, varAttLenTag,
                                                        MB_TAG_ANY ),
                                "Trouble getting conventional tag " << tag_name );
                int varAttLenSz = 0;
                MB_CHK_SET_ERR( mbImpl->tag_get_length( varAttLenTag, varAttLenSz ),
                                "Trouble getting length of conventional tag " << tag_name );
                std::vector< int > varAttLen( varAttLenSz );
                MB_CHK_SET_ERR( mbImpl->tag_get_data( varAttLenTag, &fileSet, 1, &varAttLen[0] ),
                                "Trouble getting data of conventional tag " << tag_name );
 
                MB_CHK_SET_ERR( process_concatenated_attribute( varAttPtr, varAttSz, varAttLen,
                                                                variableDataStruct.varAtts ),
                                "Trouble processing attributes of variable " << var_name );
 
                dbgOut.tprintf( 2, "Tag metadata for variable %s\n", tag_name.c_str() );
            }
            // End attribute
 
            start = i + 1;
            idxVar++;
        }  // if (p[i] == '\0')
    }
 
    // Global attributes
    tag_name         = "__GLOBAL_ATTRIBS";
    Tag globalAttTag = 0;
    MB_CHK_SET_ERR( mbImpl->tag_get_handle( tag_name.c_str(), 0, MB_TYPE_OPAQUE, globalAttTag,
                                            MB_TAG_SPARSE | MB_TAG_VARLEN ),
                    "Trouble getting conventional tag " << tag_name );
    std::vector< int > gattLen;
 
    const void* gattptr = NULL;
    int globalAttSz     = 0;
    MB_CHK_SET_ERR( mbImpl->tag_get_by_ptr( globalAttTag, &fileSet, 1, &gattptr, &globalAttSz ),
                    "Trouble getting data of conventional tag " << tag_name );
 
    dbgOut.tprintf( 2, "Tag value retrieved for %s size %d\n", tag_name.c_str(), globalAttSz );
 
    // <__GLOBAL_ATTRIBS_LEN>
    tag_name            = "__GLOBAL_ATTRIBS_LEN";
    Tag globalAttLenTag = 0;
 
    MB_CHK_SET_ERR( mbImpl->tag_get_handle( tag_name.c_str(), 0, MB_TYPE_INTEGER, globalAttLenTag, MB_TAG_ANY ),
                    "Trouble getting conventional tag " << tag_name );
    int sizeGAtt = 0;
    MB_CHK_SET_ERR( mbImpl->tag_get_length( globalAttLenTag, sizeGAtt ),
                    "Trouble getting length of conventional tag " << tag_name );
 
    gattLen.resize( sizeGAtt );
    MB_CHK_SET_ERR( mbImpl->tag_get_data( globalAttLenTag, &fileSet, 1, &gattLen[0] ),
                    "Trouble getting data of conventional tag " << tag_name );
 
    dbgOut.tprintf( 2, "Tag retrieved for variable %s\n", tag_name.c_str() );
 
    MB_CHK_SET_ERR( process_concatenated_attribute( gattptr, globalAttSz, gattLen, globalAtts ),
                    "Trouble processing global attributes" );
 
    return MB_SUCCESS;
}

References dbgOut, dimLens, dimNames, dummyVarNames, moab::WriteNC::VarData::entLoc, ErrorCode, globalAtts, grid_type, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, MB_TAG_ANY, MB_TAG_NOT_FOUND, MB_TAG_SPARSE, MB_TAG_VARLEN, MB_TYPE_INTEGER, MB_TYPE_OPAQUE, mbImpl, moab::WriteNC::VarData::numAtts, process_concatenated_attribute(), moab::Interface::tag_get_by_ptr(), moab::Interface::tag_get_data(), moab::Interface::tag_get_handle(), moab::Interface::tag_get_length(), moab::Interface::tag_get_name(), moab::DebugOutput::tprintf(), moab::WriteNC::VarData::varAtts, moab::WriteNC::VarData::varDims, varInfo, and moab::WriteNC::VarData::varName.

Referenced by write_file().

write_file()

ErrorCode moab::WriteNC::write_file ( const char *  file_name, const bool  overwrite, const FileOptions &  opts, const EntityHandle *  output_list, const int  num_sets, const std::vector< std::string > &  qa_list, const Tag *  tag_list = NULL, int  num_tags = 0, int  export_dimension = 3  )

virtual

Writes out a file.

Implements moab::WriterIface.

Definition at line 50 of file WriteNC.cpp.

{
    // See if opts has variable(s) specified
    std::vector< std::string > var_names;
    std::vector< std::string > desired_names;
    std::vector< int > tstep_nums;
    std::vector< double > tstep_vals;
 
    // Get and cache predefined tag handles
    mGlobalIdTag = mbImpl->globalId_tag();
 
    // num set has to be 1, we will write only one set, the original file set used to load
    if( num_set != 1 ) MB_SET_ERR( MB_FAILURE, "We should write only one set (the file set used to read data into)" );
 
    MB_CHK_SET_ERR( parse_options( options, var_names, desired_names, tstep_nums, tstep_vals ),
                    "Trouble parsing option string" );
 
    // Important to create some data that will be used to write the file; dimensions, variables, etc
    // new variables still need to have some way of defining their dimensions
    // maybe it will be passed as write options
    // Process the climate-style conventional tags only if the user did NOT
    // override grid_type via WRITE_FORMAT. Grid-output writers (NCWriteScrip,
    // NCWriteESMF, NCWriteDomain) synthesize their schema from mesh state
    // and don't need the prior-read __VAR_NAMES / __MESH_TYPE tag chain;
    // running process_conventional_tags would also fail on meshes that
    // weren't loaded via ReadNC (h5m, exodus, ...).
    if( grid_type.empty() )
    {
        MB_CHK_SET_ERR( process_conventional_tags( *file_set ), "Trouble processing conventional tags" );
    }
    else
    {
        dbgOut.tprintf( 2, "Skipping process_conventional_tags; grid_type already set by WRITE_FORMAT: %s\n",
                        grid_type.c_str() );
    }
 
    // Create or append the file
    if( append )
        dbgOut.tprintf( 1, "opening file %s for appending \n", file_name );
    else
        dbgOut.tprintf( 1, "creating file %s\n", file_name );
    fileName = file_name;
    int success;
 
    // Format-aware open/create via the runtime dispatch layer. For append
    // mode the format is detected from the existing file. For create mode
    // we pick CLASSIC by default (preserves the behavior of PNetCDF builds
    // which write CDF-5 via ncmpi_create) — a NetCDF-4 write path can be
    // added later behind an explicit WriteNC option.
#ifdef MOAB_HAVE_MPI
    const int write_mpi_size = isParallel ? myPcomm->proc_config().proc_size() : 1;
#else
    const int write_mpi_size = 1;
#endif
 
    if( append )
    {
        int omode = NC_WRITE;
 
        int existingFormat = NCFMT_UNKNOWN;
#ifdef MOAB_HAVE_MPI
        if( isParallel )
        {
            int rank = myPcomm->proc_config().proc_rank();
            if( rank == 0 ) existingFormat = mbnc_detect_format( file_name );
            MPI_Bcast( &existingFormat, 1, MPI_INT, 0, myPcomm->proc_config().proc_comm() );
        }
        else
#endif
        {
            existingFormat = mbnc_detect_format( file_name );
        }
 
        const NcBackend backend = mbnc_choose_backend_for_write( existingFormat, write_mpi_size );
        if( backend == NCB_NONE )
        {
            MB_SET_ERR( MB_FAILURE, "Cannot find a compatible parallel writer for appending to '"
                                        << file_name << "' (file format not recognized or no compatible backend)" );
        }
 
#ifdef MOAB_HAVE_MPI
        if( backend == NCB_NETCDF_SERIAL || write_mpi_size == 1 )
        {
            success = mbnc_open( file_name, omode, &fileId );
        }
        else
        {
            success =
                mbnc_open_par( backend, myPcomm->proc_config().proc_comm(), MPI_INFO_NULL, file_name, omode, &fileId );
        }
#else
        success = mbnc_open( file_name, omode, &fileId );
#endif
        if( success ) MB_SET_ERR( MB_FAILURE, "Trouble opening file " << file_name << " for appending" );
    }
    else
    {
        // Case when the file is new — choose classic format to match the
        // long-standing default of the PNetCDF-built path (ncmpi_create
        // defaults to CDF-5). Future: expose a "FORMAT" option on the
        // WriteNC option string to let the caller request NetCDF-4.
        int cmode = overwrite ? NC_CLOBBER : NC_NOCLOBBER;
 
        const NcBackend backend = mbnc_choose_backend_for_write( NCFMT_CLASSIC, write_mpi_size );
        if( backend == NCB_NONE )
        {
            MB_SET_ERR( MB_FAILURE, "Cannot find a compatible parallel writer for creating '" << file_name << "'" );
        }
 
#ifdef MOAB_HAVE_MPI
        if( backend == NCB_NETCDF_SERIAL || write_mpi_size == 1 )
        {
            success = mbnc_create( file_name, cmode, &fileId );
        }
        else
        {
            success =
                mbnc_create_par( backend, myPcomm->proc_config().proc_comm(), MPI_INFO_NULL, file_name, cmode, &fileId );
        }
#else
        success = mbnc_create( file_name, cmode, &fileId );
#endif
        if( success ) MB_SET_ERR( MB_FAILURE, "Trouble creating file " << file_name << " for writing" );
    }
 
    if( NULL != myHelper ) delete myHelper;
 
    // Get appropriate helper instance for WriteNC class based on some info in the file set
    myHelper = NCWriteHelper::get_nc_helper( this, fileId, options, *file_set );
    if( NULL == myHelper )
    {
        MB_SET_ERR( MB_FAILURE, "Failed to get NCWriteHelper class instance" );
    }
 
    MB_CHK_SET_ERR( myHelper->collect_mesh_info(), "Trouble collecting mesh information" );
 
    MB_CHK_SET_ERR( myHelper->collect_variable_data( var_names, tstep_nums ), "Trouble collecting variable data" );
 
    MB_CHK_SET_ERR( myHelper->init_file( var_names, desired_names, append ), "Trouble initializing file" );
 
    MB_CHK_SET_ERR( myHelper->write_values( var_names, tstep_nums ), "Trouble writing values to file" );
 
    success = NCFUNC( close )( fileId );
    if( success ) MB_SET_ERR( MB_FAILURE, "Trouble closing file" );
 
    return MB_SUCCESS;
}

References append, moab::NCWriteHelper::collect_mesh_info(), moab::NCWriteHelper::collect_variable_data(), dbgOut, fileId, fileName, moab::NCWriteHelper::get_nc_helper(), moab::Interface::globalId_tag(), grid_type, moab::NCWriteHelper::init_file(), isParallel, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, mbImpl, moab::mbnc_choose_backend_for_write(), moab::mbnc_create(), moab::mbnc_detect_format(), moab::mbnc_open(), mGlobalIdTag, myHelper, moab::NCB_NETCDF_SERIAL, moab::NCB_NONE, moab::NCFMT_CLASSIC, moab::NCFMT_UNKNOWN, NCFUNC, parse_options(), process_conventional_tags(), moab::DebugOutput::tprintf(), and moab::NCWriteHelper::write_values().

Friends And Related Function Documentation

NCWriteDomain

friend class NCWriteDomain

friend

Definition at line 83 of file WriteNC.hpp.

NCWriteESMF

friend class NCWriteESMF

friend

Definition at line 82 of file WriteNC.hpp.

NCWriteEuler

friend class NCWriteEuler

friend

Definition at line 76 of file WriteNC.hpp.

NCWriteFV

friend class NCWriteFV

friend

Definition at line 77 of file WriteNC.hpp.

NCWriteGCRM

friend class NCWriteGCRM

friend

Definition at line 80 of file WriteNC.hpp.

NCWriteHelper

friend class NCWriteHelper

friend

Definition at line 73 of file WriteNC.hpp.

NCWriteHOMME

friend class NCWriteHOMME

friend

Definition at line 78 of file WriteNC.hpp.

NCWriteMPAS

friend class NCWriteMPAS

friend

Definition at line 79 of file WriteNC.hpp.

NCWriteScrip

friend class NCWriteScrip

friend

Definition at line 81 of file WriteNC.hpp.

ScdNCWriteHelper

friend class ScdNCWriteHelper

friend

Definition at line 74 of file WriteNC.hpp.

UcdNCWriteHelper

friend class UcdNCWriteHelper

friend

Definition at line 75 of file WriteNC.hpp.

Member Data Documentation

append

bool moab::WriteNC::append

private

Definition at line 206 of file WriteNC.hpp.

Referenced by parse_options(), and write_file().

dbgOut

DebugOutput moab::WriteNC::dbgOut

private

Debug stuff.

Definition at line 197 of file WriteNC.hpp.

Referenced by moab::NCWriteDomain::collect_mesh_info(), moab::NCWriteESMF::collect_mesh_info(), moab::NCWriteScrip::collect_mesh_info(), moab::NCWriteHelper::collect_variable_data(), moab::NCWriteHelper::init_file(), parse_options(), process_concatenated_attribute(), process_conventional_tags(), write_file(), moab::NCWriteDomain::write_values(), moab::NCWriteESMF::write_values(), and moab::NCWriteScrip::write_values().

dimLens

std::vector< int > moab::WriteNC::dimLens

private

Dimension lengths.

Definition at line 156 of file WriteNC.hpp.

Referenced by moab::NCWriteGCRM::collect_mesh_info(), moab::NCWriteHOMME::collect_mesh_info(), moab::NCWriteMPAS::collect_mesh_info(), moab::ScdNCWriteHelper::collect_mesh_info(), moab::NCWriteGCRM::collect_variable_data(), moab::NCWriteHelper::collect_variable_data(), moab::NCWriteMPAS::collect_variable_data(), and process_conventional_tags().

dimNames

std::vector< std::string > moab::WriteNC::dimNames

private

This info will be reconstructed from metadata stored on conventional fileSet tags Dimension names.

Definition at line 153 of file WriteNC.hpp.

Referenced by moab::NCWriteGCRM::collect_mesh_info(), moab::NCWriteHOMME::collect_mesh_info(), moab::NCWriteMPAS::collect_mesh_info(), moab::ScdNCWriteHelper::collect_mesh_info(), moab::NCWriteGCRM::collect_variable_data(), moab::NCWriteHelper::collect_variable_data(), moab::NCWriteMPAS::collect_variable_data(), moab::NCWriteHelper::init_file(), and process_conventional_tags().

dummyVarNames

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

private

Dummy variables (for dimensions that have no corresponding coordinate variables)

Definition at line 162 of file WriteNC.hpp.

Referenced by moab::NCWriteHelper::collect_variable_data(), moab::NCWriteHelper::init_file(), process_conventional_tags(), and moab::NCWriteHelper::write_values().

fileId

int moab::WriteNC::fileId

private

File numbers assigned by (p)netcdf.

Definition at line 194 of file WriteNC.hpp.

Referenced by write_file().

fileName

const char* moab::WriteNC::fileName

private

File var.

Definition at line 191 of file WriteNC.hpp.

Referenced by write_file().

globalAtts

std::map< std::string, AttData > moab::WriteNC::globalAtts

private

Global attribs.

Definition at line 165 of file WriteNC.hpp.

Referenced by moab::NCWriteHelper::init_file(), and process_conventional_tags().

grid_type

std::string moab::WriteNC::grid_type

private

CAM Euler, etc,.

Definition at line 215 of file WriteNC.hpp.

Referenced by moab::NCWriteHelper::get_nc_helper(), parse_options(), process_conventional_tags(), and write_file().

isParallel

bool moab::WriteNC::isParallel

private

Are we writing in parallel? (probably in the future)

Definition at line 212 of file WriteNC.hpp.

Referenced by moab::NCWriteGCRM::collect_mesh_info(), moab::NCWriteHOMME::collect_mesh_info(), moab::NCWriteMPAS::collect_mesh_info(), moab::NCWriteDomain::collect_mesh_info(), moab::NCWriteESMF::collect_mesh_info(), moab::ScdNCWriteHelper::collect_mesh_info(), moab::NCWriteScrip::collect_mesh_info(), parse_options(), write_file(), moab::NCWriteHelper::write_set_variables(), moab::NCWriteDomain::write_values(), moab::NCWriteESMF::write_values(), and moab::NCWriteScrip::write_values().

mbImpl

Interface* moab::WriteNC::mbImpl

private

Interface instance.

Definition at line 187 of file WriteNC.hpp.

Referenced by moab::NCWriteGCRM::collect_mesh_info(), moab::NCWriteHOMME::collect_mesh_info(), moab::NCWriteMPAS::collect_mesh_info(), moab::NCWriteDomain::collect_mesh_info(), moab::NCWriteESMF::collect_mesh_info(), moab::ScdNCWriteHelper::collect_mesh_info(), moab::NCWriteScrip::collect_mesh_info(), moab::NCWriteHelper::collect_variable_data(), parse_options(), process_conventional_tags(), write_file(), moab::NCWriteGCRM::write_nonset_variables(), moab::NCWriteHOMME::write_nonset_variables(), moab::NCWriteMPAS::write_nonset_variables(), moab::ScdNCWriteHelper::write_nonset_variables(), and ~WriteNC().

mGlobalIdTag

Tag moab::WriteNC::mGlobalIdTag

private

Cached tags for writing. This will be important for ordering the data, in parallel.

Definition at line 209 of file WriteNC.hpp.

Referenced by moab::NCWriteGCRM::collect_mesh_info(), moab::NCWriteHOMME::collect_mesh_info(), moab::NCWriteMPAS::collect_mesh_info(), moab::NCWriteDomain::collect_mesh_info(), moab::NCWriteESMF::collect_mesh_info(), moab::NCWriteScrip::collect_mesh_info(), and write_file().

mWriteIface

WriteUtilIface* moab::WriteNC::mWriteIface

private

Definition at line 188 of file WriteNC.hpp.

Referenced by WriteNC(), and ~WriteNC().

myHelper

NCWriteHelper* moab::WriteNC::myHelper

private

Helper class instance.

Definition at line 218 of file WriteNC.hpp.

Referenced by write_file(), and ~WriteNC().

noMesh

bool moab::WriteNC::noMesh

private

Write options.

Definition at line 204 of file WriteNC.hpp.

Referenced by parse_options().

noVars

bool moab::WriteNC::noVars

private

Definition at line 205 of file WriteNC.hpp.

Referenced by parse_options().

usedCoordinates

std::set< std::string > moab::WriteNC::usedCoordinates

private

Will collect used dimensions (coordinate variables)

Definition at line 159 of file WriteNC.hpp.

Referenced by moab::NCWriteHelper::collect_variable_data(), moab::NCWriteHelper::init_file(), and moab::NCWriteHelper::write_values().

varInfo

std::map< std::string, VarData > moab::WriteNC::varInfo

private

Variable info.

Definition at line 168 of file WriteNC.hpp.

Referenced by moab::NCWriteGCRM::collect_variable_data(), moab::NCWriteHelper::collect_variable_data(), moab::NCWriteHOMME::collect_variable_data(), moab::NCWriteMPAS::collect_variable_data(), moab::ScdNCWriteHelper::collect_variable_data(), moab::NCWriteHelper::init_file(), process_conventional_tags(), and moab::NCWriteHelper::write_values().

---

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

• WriteNC.hpp
• WriteNC.cpp