#include <NCWriteDomain.hpp>

Inheritance diagram for moab::NCWriteDomain:

Collaboration diagram for moab::NCWriteDomain:

Public Member Functions
	NCWriteDomain (WriteNC *writeNC, int fileId, const FileOptions &opts, EntityHandle fileSet)

virtual	~NCWriteDomain () override

ErrorCode	collect_mesh_info () override
	Collect necessary info about local mesh (implemented in child classes) More...

ErrorCode	init_file (std::vector< std::string > &var_names, std::vector< std::string > &desired_names, bool _append) override
	Initialize file: this is where all defines are done. Virtual so that grid-output writers (NCWriteScrip / NCWriteESMF / NCWriteDomain) can synthesize a fresh schema from mesh state instead of going through the climate var_names plumbing. More...

ErrorCode	write_values (std::vector< std::string > &var_names, std::vector< int > &tstep_nums) override
	Take the info from VarData and write first non-set variables, then set variables. Virtual for the same reason as init_file. More...

Public Member Functions inherited from moab::NCWriteHelper
	NCWriteHelper (WriteNC *writeNC, int fileId, const FileOptions &opts, EntityHandle fileSet)

virtual	~NCWriteHelper ()

virtual ErrorCode	collect_variable_data (std::vector< std::string > &var_names, std::vector< int > &tstep_nums)
	Collect data for specified variables (partially implemented in child classes) More...

Protected Member Functions
ErrorCode	write_nonset_variables (std::vector< WriteNC::VarData > &vdatas, std::vector< int > &tstep_nums) override

Private Attributes
long	mLocalCells

long	mGlobalCells

int	mMaxCornersGlobal

long	mNi
	On-disk grid extents. For now we always emit ni = mGlobalCells, nj = 1 — i.e. a flat layout that the CESM domain reader handles identically to the rectangular case but with j collapsed. More...

long	mNj

bool	mHasAreas

bool	mHasMask

bool	mHasFrac

std::vector< int >	mLocalGids

std::vector< double >	mXc

std::vector< double >	mYc

std::vector< double >	mXv

std::vector< double >	mYv

std::vector< int >	mMask

std::vector< double >	mAreas

std::vector< double >	mFrac

int	mDimN

int	mDimNi

int	mDimNj

int	mDimNv

int	mVarXc

int	mVarYc

int	mVarXv

int	mVarYv

int	mVarMask

int	mVarArea

int	mVarFrac

Additional Inherited Members
Static Public Member Functions inherited from moab::NCWriteHelper
static NCWriteHelper *	get_nc_helper (WriteNC *writeNC, int fileId, const FileOptions &opts, EntityHandle fileSet)
	Get appropriate helper instance for WriteNC class based on some info in the file set. More...

Protected Attributes inherited from moab::NCWriteHelper
WriteNC *	_writeNC
	Allow NCWriteHelper to directly access members of WriteNC. More...

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

const FileOptions &	_opts

EntityHandle	_fileSet

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

int	nLevels

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

int	levDim

Range	localCellsOwned
	Local owned cells, edges and vertices. More...

Range	localEdgesOwned

Range	localVertsOwned

std::vector< double >	timeStepVals
	Time values of output timesteps. More...

Detailed Description

Definition at line 47 of file NCWriteDomain.hpp.

Constructor & Destructor Documentation

◆ NCWriteDomain()

moab::NCWriteDomain::NCWriteDomain	(	WriteNC *	writeNC,
		int	fileId,
		const FileOptions &	opts,
		EntityHandle	fileSet
	)

inline

Definition at line 50 of file NCWriteDomain.hpp.

         : NCWriteHelper( writeNC, fileId, opts, fileSet ),
           mLocalCells( 0 ), mGlobalCells( 0 ), mMaxCornersGlobal( 0 ),
           mNi( 0 ), mNj( 1 ), mHasAreas( false ), mHasMask( false ), mHasFrac( false ),
           mDimN( -1 ), mDimNi( -1 ), mDimNj( -1 ), mDimNv( -1 ),
           mVarXc( -1 ), mVarYc( -1 ), mVarXv( -1 ), mVarYv( -1 ),
           mVarMask( -1 ), mVarArea( -1 ), mVarFrac( -1 )
     {
     }

◆ ~NCWriteDomain()

moab::NCWriteDomain::~NCWriteDomain ( )

overridevirtual

Definition at line 19 of file NCWriteDomain.cpp.

19 {}

Member Function Documentation

◆ collect_mesh_info()

ErrorCode moab::NCWriteDomain::collect_mesh_info ( )

overridevirtual

Collect necessary info about local mesh (implemented in child classes)

Implements moab::NCWriteHelper.

Definition at line 48 of file NCWriteDomain.cpp.

 {
     Interface*& mbImpl  = _writeNC->mbImpl;
     Tag& mGlobalIdTag   = _writeNC->mGlobalIdTag;
     DebugOutput& dbgOut = _writeNC->dbgOut;
  
     Range allCells;
     MB_CHK_SET_ERR( mbImpl->get_entities_by_dimension( _fileSet, 2, allCells ),
                     "Failed to gather 2-D cells for Domain write" );
     if( allCells.empty() ) MB_SET_ERR( MB_FAILURE, "No 2-D cells in file set; cannot write Domain grid" );
  
     localCellsOwned = allCells;
 #ifdef MOAB_HAVE_MPI
     bool& isParallel = _writeNC->isParallel;
     if( isParallel )
     {
         ParallelComm*& myPcomm = _writeNC->myPcomm;
         if( myPcomm && myPcomm->proc_config().proc_size() > 1 )
         {
             MB_CHK_SET_ERR( myPcomm->filter_pstatus( localCellsOwned, PSTATUS_NOT_OWNED, PSTATUS_NOT ),
                             "Failed to filter owned cells for Domain write" );
         }
     }
 #endif
  
     mLocalCells = static_cast< long >( localCellsOwned.size() );
  
     // Global max corners per cell.
     int localMaxCorners = 0;
     for( Range::iterator cit = localCellsOwned.begin(); cit != localCellsOwned.end(); ++cit )
     {
         const EntityHandle* conn = nullptr;
         int numConn              = 0;
         if( MB_SUCCESS == mbImpl->get_connectivity( *cit, conn, numConn ) && numConn > localMaxCorners )
             localMaxCorners = numConn;
     }
 #ifdef MOAB_HAVE_MPI
     if( _writeNC->isParallel && _writeNC->myPcomm )
     {
         MPI_Allreduce( &localMaxCorners, &mMaxCornersGlobal, 1, MPI_INT, MPI_MAX,
                        _writeNC->myPcomm->proc_config().proc_comm() );
     }
     else
 #endif
     {
         mMaxCornersGlobal = localMaxCorners;
     }
     if( mMaxCornersGlobal <= 0 ) MB_SET_ERR( MB_FAILURE, "Cells reported zero connectivity; cannot write Domain" );
  
     mLocalGids.assign( mLocalCells, 0 );
     mXc.assign( mLocalCells, 0.0 );
     mYc.assign( mLocalCells, 0.0 );
     mXv.assign( static_cast< size_t >( mLocalCells ) * mMaxCornersGlobal, 0.0 );
     mYv.assign( static_cast< size_t >( mLocalCells ) * mMaxCornersGlobal, 0.0 );
     mMask.assign( mLocalCells, 1 );
  
     long ci = 0;
     for( Range::iterator cit = localCellsOwned.begin(); cit != localCellsOwned.end(); ++cit, ++ci )
     {
         int gid = 0;
         if( mGlobalIdTag ) mbImpl->tag_get_data( mGlobalIdTag, &( *cit ), 1, &gid );
         mLocalGids[ci] = gid;
  
         const EntityHandle* conn = nullptr;
         int numConn              = 0;
         MB_CHK_SET_ERR( mbImpl->get_connectivity( *cit, conn, numConn ), "Cell connectivity lookup failed" );
  
         double cx = 0.0, cy = 0.0, cz = 0.0;
         double firstLat = 0.0, firstLon = 0.0;
         for( int k = 0; k < numConn; ++k )
         {
             double vc[3] = { 0.0, 0.0, 0.0 };
             MB_CHK_SET_ERR( mbImpl->get_coords( &conn[k], 1, vc ), "Vertex coordinate lookup failed" );
             cx += vc[0];
             cy += vc[1];
             cz += vc[2];
             double vlat = 0.0, vlon = 0.0;
             xyz_to_latlon_deg( vc[0], vc[1], vc[2], vlat, vlon );
             mYv[ci * mMaxCornersGlobal + k] = vlat;
             mXv[ci * mMaxCornersGlobal + k] = vlon;
             if( k == 0 )
             {
                 firstLat = vlat;
                 firstLon = vlon;
             }
         }
         for( int k = numConn; k < mMaxCornersGlobal; ++k )
         {
             mYv[ci * mMaxCornersGlobal + k] = firstLat;
             mXv[ci * mMaxCornersGlobal + k] = firstLon;
         }
         cx /= numConn;
         cy /= numConn;
         cz /= numConn;
         xyz_to_latlon_deg( cx, cy, cz, mYc[ci], mXc[ci] );
     }
  
     // Mask is required by the CESM domain schema; pull values from
     // DOMAIN_MASK if present, otherwise the default-1 mMask buffer
     // populated above is what gets written.
     Tag maskTag = 0;
     if( MB_SUCCESS == mbImpl->tag_get_handle( "DOMAIN_MASK", 1, MB_TYPE_INTEGER, maskTag ) && maskTag )
     {
         (void)mbImpl->tag_get_data( maskTag, localCellsOwned, mMask.data() );
     }
     mHasMask = true;  // schema-required field; always emit
  
     Tag areaTag = 0;
     if( MB_SUCCESS == mbImpl->tag_get_handle( "GRID_AREA", 1, MB_TYPE_DOUBLE, areaTag ) && areaTag )
     {
         mAreas.assign( mLocalCells, 0.0 );
         if( MB_SUCCESS == mbImpl->tag_get_data( areaTag, localCellsOwned, mAreas.data() ) )
             mHasAreas = true;
         else
             mAreas.clear();
     }
     Tag fracTag = 0;
     if( MB_SUCCESS == mbImpl->tag_get_handle( "DOMAIN_FRAC", 1, MB_TYPE_DOUBLE, fracTag ) && fracTag )
     {
         mFrac.assign( mLocalCells, 1.0 );
         if( MB_SUCCESS == mbImpl->tag_get_data( fracTag, localCellsOwned, mFrac.data() ) )
             mHasFrac = true;
         else
             mFrac.clear();
     }
     // frac is also conventionally always present in CESM domain files; emit 1.0's by default.
     if( !mHasFrac )
     {
         mFrac.assign( mLocalCells, 1.0 );
         mHasFrac = true;
     }
  
     mGlobalCells = mLocalCells;
 #ifdef MOAB_HAVE_MPI
     if( _writeNC->isParallel && _writeNC->myPcomm )
     {
         long localN = mLocalCells;
         MPI_Allreduce( &localN, &mGlobalCells, 1, MPI_LONG, MPI_SUM,
                        _writeNC->myPcomm->proc_config().proc_comm() );
     }
 #endif
     // Flat layout: nj=1, ni=total cells. Matches the CESM convention for
     // domain files derived from unstructured meshes (see e.g.
     // domain.ocn.ne4np4_oQU240 ships with ni=866, nj=1).
     mNj = 1;
     mNi = mGlobalCells;
  
     dbgOut.tprintf( 1, "  Domain write: local_cells=%ld global_cells=%ld ni=%ld nj=%ld max_corners=%d\n", mLocalCells,
                     mGlobalCells, mNi, mNj, mMaxCornersGlobal );
  
     return MB_SUCCESS;
 }

References moab::NCWriteHelper::_fileSet, moab::NCWriteHelper::_writeNC, moab::Range::begin(), moab::WriteNC::dbgOut, moab::Range::empty(), moab::Range::end(), moab::ParallelComm::filter_pstatus(), moab::Interface::get_connectivity(), moab::Interface::get_coords(), moab::Interface::get_entities_by_dimension(), moab::WriteNC::isParallel, moab::NCWriteHelper::localCellsOwned, mAreas, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, moab::WriteNC::mbImpl, mFrac, mGlobalCells, moab::WriteNC::mGlobalIdTag, mHasAreas, mHasFrac, mHasMask, mLocalCells, mLocalGids, mMask, mMaxCornersGlobal, mNi, mNj, mXc, mXv, mYc, mYv, moab::ParallelComm::proc_config(), moab::ProcConfig::proc_size(), PSTATUS_NOT, PSTATUS_NOT_OWNED, moab::Range::size(), moab::Interface::tag_get_data(), moab::Interface::tag_get_handle(), moab::DebugOutput::tprintf(), and moab::anonymous_namespace{NCWriteDomain.cpp}::xyz_to_latlon_deg().

◆ init_file()

ErrorCode moab::NCWriteDomain::init_file	(	std::vector< std::string > &	var_names,
		std::vector< std::string > &	desired_names,
		bool	_append
	)

overridevirtual

Initialize file: this is where all defines are done. Virtual so that grid-output writers (NCWriteScrip / NCWriteESMF / NCWriteDomain) can synthesize a fresh schema from mesh state instead of going through the climate var_names plumbing.

Reimplemented from moab::NCWriteHelper.

Definition at line 201 of file NCWriteDomain.cpp.

 {
     if( NCFUNC( def_dim )( _fileId, "n", static_cast< size_t >( mGlobalCells ), &mDimN ) )
         MB_SET_ERR( MB_FAILURE, "Failed to define n dim" );
     if( NCFUNC( def_dim )( _fileId, "ni", static_cast< size_t >( mNi ), &mDimNi ) )
         MB_SET_ERR( MB_FAILURE, "Failed to define ni dim" );
     if( NCFUNC( def_dim )( _fileId, "nj", static_cast< size_t >( mNj ), &mDimNj ) )
         MB_SET_ERR( MB_FAILURE, "Failed to define nj dim" );
     if( NCFUNC( def_dim )( _fileId, "nv", static_cast< size_t >( mMaxCornersGlobal ), &mDimNv ) )
         MB_SET_ERR( MB_FAILURE, "Failed to define nv dim" );
  
     // Variable dims: arrays are (nj, ni) or (nj, ni, nv). j is the slow axis.
     const int dimsCenter[2] = { mDimNj, mDimNi };
     const int dimsVertex[3] = { mDimNj, mDimNi, mDimNv };
  
     if( NCFUNC( def_var )( _fileId, "xc", NC_DOUBLE, 2, dimsCenter, &mVarXc ) )
         MB_SET_ERR( MB_FAILURE, "Failed to define xc var" );
     if( NCFUNC( def_var )( _fileId, "yc", NC_DOUBLE, 2, dimsCenter, &mVarYc ) )
         MB_SET_ERR( MB_FAILURE, "Failed to define yc var" );
     if( NCFUNC( def_var )( _fileId, "xv", NC_DOUBLE, 3, dimsVertex, &mVarXv ) )
         MB_SET_ERR( MB_FAILURE, "Failed to define xv var" );
     if( NCFUNC( def_var )( _fileId, "yv", NC_DOUBLE, 3, dimsVertex, &mVarYv ) )
         MB_SET_ERR( MB_FAILURE, "Failed to define yv var" );
     if( NCFUNC( def_var )( _fileId, "mask", NC_INT, 2, dimsCenter, &mVarMask ) )
         MB_SET_ERR( MB_FAILURE, "Failed to define mask var" );
     if( NCFUNC( def_var )( _fileId, "area", NC_DOUBLE, 2, dimsCenter, &mVarArea ) )
         MB_SET_ERR( MB_FAILURE, "Failed to define area var" );
     if( NCFUNC( def_var )( _fileId, "frac", NC_DOUBLE, 2, dimsCenter, &mVarFrac ) )
         MB_SET_ERR( MB_FAILURE, "Failed to define frac var" );
  
     // CF-style metadata matching the canonical CESM domain file schema.
     const char* deg_e   = "degrees_east";
     const char* deg_n   = "degrees_north";
     const char* rad2    = "radian2";
     const char* xv_name = "longitude of grid cell verticies";
     const char* yv_name = "latitude of grid cell verticies";
     const char* xc_name = "longitude of grid cell center";
     const char* yc_name = "latitude of grid cell center";
     const char* m_name  = "domain mask";
     const char* a_name  = "area of grid cell in radians squared";
     const char* f_name  = "fraction of grid cell that is active";
  
     NCFUNC( put_att_text )( _fileId, mVarXc, "long_name", std::strlen( xc_name ), xc_name );
     NCFUNC( put_att_text )( _fileId, mVarXc, "units", std::strlen( deg_e ), deg_e );
     NCFUNC( put_att_text )( _fileId, mVarXc, "bounds", 2, "xv" );
  
     NCFUNC( put_att_text )( _fileId, mVarYc, "long_name", std::strlen( yc_name ), yc_name );
     NCFUNC( put_att_text )( _fileId, mVarYc, "units", std::strlen( deg_n ), deg_n );
     NCFUNC( put_att_text )( _fileId, mVarYc, "bounds", 2, "yv" );
  
     NCFUNC( put_att_text )( _fileId, mVarXv, "long_name", std::strlen( xv_name ), xv_name );
     NCFUNC( put_att_text )( _fileId, mVarXv, "units", std::strlen( deg_e ), deg_e );
  
     NCFUNC( put_att_text )( _fileId, mVarYv, "long_name", std::strlen( yv_name ), yv_name );
     NCFUNC( put_att_text )( _fileId, mVarYv, "units", std::strlen( deg_n ), deg_n );
  
     NCFUNC( put_att_text )( _fileId, mVarMask, "long_name", std::strlen( m_name ), m_name );
     NCFUNC( put_att_text )( _fileId, mVarMask, "note", 8, "unitless" );
     NCFUNC( put_att_text )( _fileId, mVarMask, "coordinates", 5, "xc yc" );
     NCFUNC( put_att_text )( _fileId, mVarMask, "comment", 36, "0 value indicates cell is not active" );
  
     NCFUNC( put_att_text )( _fileId, mVarArea, "long_name", std::strlen( a_name ), a_name );
     NCFUNC( put_att_text )( _fileId, mVarArea, "units", std::strlen( rad2 ), rad2 );
     NCFUNC( put_att_text )( _fileId, mVarArea, "coordinates", 5, "xc yc" );
  
     NCFUNC( put_att_text )( _fileId, mVarFrac, "long_name", std::strlen( f_name ), f_name );
     NCFUNC( put_att_text )( _fileId, mVarFrac, "coordinates", 5, "xc yc" );
     NCFUNC( put_att_text )( _fileId, mVarFrac, "note", 8, "unitless" );
  
     const char* title = "MOAB:NCWriteDomain generated CESM-style domain file";
     NCFUNC( put_att_text )( _fileId, NC_GLOBAL, "title", std::strlen( title ), title );
     const char* conv = "CF-1.0";
     NCFUNC( put_att_text )( _fileId, NC_GLOBAL, "Conventions", std::strlen( conv ), conv );
  
     if( NCFUNC( enddef )( _fileId ) ) MB_SET_ERR( MB_FAILURE, "enddef failed for Domain write" );
  
     return MB_SUCCESS;
 }

References moab::NCWriteHelper::_fileId, MB_SET_ERR, MB_SUCCESS, mDimN, mDimNi, mDimNj, mDimNv, mGlobalCells, mMaxCornersGlobal, mNi, mNj, mVarArea, mVarFrac, mVarMask, mVarXc, mVarXv, mVarYc, mVarYv, and NCFUNC.

◆ write_nonset_variables()

ErrorCode moab::NCWriteDomain::write_nonset_variables	(	std::vector< WriteNC::VarData > &	vdatas,
		std::vector< int > &	tstep_nums
	)

overrideprotectedvirtual

Implements moab::NCWriteHelper.

Definition at line 419 of file NCWriteDomain.cpp.

 {
     return MB_SUCCESS;
 }

References MB_SUCCESS.

◆ write_values()

ErrorCode moab::NCWriteDomain::write_values	(	std::vector< std::string > &	var_names,
		std::vector< int > &	tstep_nums
	)

overridevirtual

Take the info from VarData and write first non-set variables, then set variables. Virtual for the same reason as init_file.

Reimplemented from moab::NCWriteHelper.

Definition at line 282 of file NCWriteDomain.cpp.

 {
     DebugOutput& dbgOut = _writeNC->dbgOut;
  
     auto writeAll = [&]( const std::vector< int >& allGids, const std::vector< double >& allXc,
                          const std::vector< double >& allYc, const std::vector< double >& allXv,
                          const std::vector< double >& allYv, const std::vector< int >& allMask,
                          const std::vector< double >& allAreas, const std::vector< double >& allFrac ) -> ErrorCode {
         const long N    = static_cast< long >( allGids.size() );
         const int  ncpc = mMaxCornersGlobal;
  
         // Sort by global id for BfB output across rank counts.
         std::vector< long > perm( N );
         for( long i = 0; i < N; ++i )
             perm[i] = i;
         std::sort( perm.begin(), perm.end(), [&]( long a, long b ) { return allGids[a] < allGids[b]; } );
  
         std::vector< double > sXc( N ), sYc( N ), sXv( N * ncpc ), sYv( N * ncpc );
         std::vector< int >    sMask( N );
         std::vector< double > sArea( N, 0.0 ), sFrac( N, 1.0 );
         const bool            haveArea = !allAreas.empty();
         for( long i = 0; i < N; ++i )
         {
             const long src = perm[i];
             sXc[i]   = allXc[src];
             sYc[i]   = allYc[src];
             sMask[i] = allMask[src];
             if( haveArea ) sArea[i] = allAreas[src];
             if( !allFrac.empty() ) sFrac[i] = allFrac[src];
             for( int k = 0; k < ncpc; ++k )
             {
                 sXv[i * ncpc + k] = allXv[src * ncpc + k];
                 sYv[i * ncpc + k] = allYv[src * ncpc + k];
             }
         }
  
         // Writes are 2-D (nj=1, ni=N) for centers and mask/area/frac;
         // 3-D (nj=1, ni=N, nv=ncpc) for the vertex arrays.
         const size_t s2[2] = { 0, 0 };
         const size_t c2[2] = { 1, static_cast< size_t >( N ) };
         const size_t s3[3] = { 0, 0, 0 };
         const size_t c3[3] = { 1, static_cast< size_t >( N ), static_cast< size_t >( ncpc ) };
  
         if( NCFUNCAP( _vara_double )( _fileId, mVarXc, s2, c2, sXc.data() ) )
             MB_SET_ERR( MB_FAILURE, "Failed to write xc" );
         if( NCFUNCAP( _vara_double )( _fileId, mVarYc, s2, c2, sYc.data() ) )
             MB_SET_ERR( MB_FAILURE, "Failed to write yc" );
         if( NCFUNCAP( _vara_double )( _fileId, mVarXv, s3, c3, sXv.data() ) )
             MB_SET_ERR( MB_FAILURE, "Failed to write xv" );
         if( NCFUNCAP( _vara_double )( _fileId, mVarYv, s3, c3, sYv.data() ) )
             MB_SET_ERR( MB_FAILURE, "Failed to write yv" );
         if( NCFUNCAP( _vara_int )( _fileId, mVarMask, s2, c2, sMask.data() ) )
             MB_SET_ERR( MB_FAILURE, "Failed to write mask" );
         if( NCFUNCAP( _vara_double )( _fileId, mVarArea, s2, c2, sArea.data() ) )
             MB_SET_ERR( MB_FAILURE, "Failed to write area" );
         if( NCFUNCAP( _vara_double )( _fileId, mVarFrac, s2, c2, sFrac.data() ) )
             MB_SET_ERR( MB_FAILURE, "Failed to write frac" );
         return MB_SUCCESS;
     };
  
 #ifdef MOAB_HAVE_MPI
     if( _writeNC->isParallel && _writeNC->myPcomm && _writeNC->myPcomm->proc_config().proc_size() > 1 )
     {
         MPI_Comm comm = _writeNC->myPcomm->proc_config().proc_comm();
         const int rank = _writeNC->myPcomm->proc_config().proc_rank();
         const int size = _writeNC->myPcomm->proc_config().proc_size();
         const int ncpc = mMaxCornersGlobal;
  
         int myN = static_cast< int >( mLocalCells );
         std::vector< int > counts( size, 0 ), displs( size, 0 );
         MPI_Gather( &myN, 1, MPI_INT, counts.data(), 1, MPI_INT, 0, comm );
         if( rank == 0 )
         {
             int acc = 0;
             for( int i = 0; i < size; ++i )
             {
                 displs[i] = acc;
                 acc += counts[i];
             }
         }
  
         std::vector< int >    allGids;
         std::vector< double > allXc, allYc, allXv, allYv;
         std::vector< int >    allMask;
         std::vector< double > allAreas, allFrac;
         if( rank == 0 )
         {
             allGids.resize( mGlobalCells );
             allXc.resize( mGlobalCells );
             allYc.resize( mGlobalCells );
             allXv.resize( static_cast< size_t >( mGlobalCells ) * ncpc );
             allYv.resize( static_cast< size_t >( mGlobalCells ) * ncpc );
             allMask.resize( mGlobalCells );
             if( mHasAreas ) allAreas.resize( mGlobalCells );
             allFrac.resize( mGlobalCells );
         }
  
         MPI_Gatherv( mLocalGids.data(), myN, MPI_INT, allGids.data(), counts.data(), displs.data(), MPI_INT, 0, comm );
         MPI_Gatherv( mXc.data(), myN, MPI_DOUBLE, allXc.data(), counts.data(), displs.data(), MPI_DOUBLE, 0, comm );
         MPI_Gatherv( mYc.data(), myN, MPI_DOUBLE, allYc.data(), counts.data(), displs.data(), MPI_DOUBLE, 0, comm );
         MPI_Gatherv( mMask.data(), myN, MPI_INT, allMask.data(), counts.data(), displs.data(), MPI_INT, 0, comm );
         if( mHasAreas )
             MPI_Gatherv( mAreas.data(), myN, MPI_DOUBLE, allAreas.data(), counts.data(), displs.data(), MPI_DOUBLE, 0,
                          comm );
         MPI_Gatherv( mFrac.data(), myN, MPI_DOUBLE, allFrac.data(), counts.data(), displs.data(), MPI_DOUBLE, 0, comm );
  
         std::vector< int > countsC( size, 0 ), displsC( size, 0 );
         if( rank == 0 )
         {
             int acc = 0;
             for( int i = 0; i < size; ++i )
             {
                 countsC[i] = counts[i] * ncpc;
                 displsC[i] = acc;
                 acc += countsC[i];
             }
         }
         MPI_Gatherv( mXv.data(), myN * ncpc, MPI_DOUBLE, allXv.data(), countsC.data(), displsC.data(), MPI_DOUBLE, 0,
                      comm );
         MPI_Gatherv( mYv.data(), myN * ncpc, MPI_DOUBLE, allYv.data(), countsC.data(), displsC.data(), MPI_DOUBLE, 0,
                      comm );
  
         ErrorCode rc = MB_SUCCESS;
         if( rank == 0 ) rc = writeAll( allGids, allXc, allYc, allXv, allYv, allMask, allAreas, allFrac );
         int rcInt = static_cast< int >( rc );
         MPI_Bcast( &rcInt, 1, MPI_INT, 0, comm );
         if( rcInt != MB_SUCCESS ) MB_SET_ERR( MB_FAILURE, "Domain write failed on rank 0" );
  
         dbgOut.tprintf( 1, "  Domain write: gathered+wrote %ld cells from %d ranks\n", mGlobalCells, size );
         return MB_SUCCESS;
     }
 #endif
  
     return writeAll( mLocalGids, mXc, mYc, mXv, mYv, mMask, mAreas, mFrac );
 }

References moab::NCWriteHelper::_fileId, moab::NCWriteHelper::_writeNC, moab::WriteNC::dbgOut, ErrorCode, moab::WriteNC::isParallel, mAreas, MB_SET_ERR, MB_SUCCESS, mFrac, mGlobalCells, mHasAreas, mLocalCells, mLocalGids, mMask, mMaxCornersGlobal, mVarArea, mVarFrac, mVarMask, mVarXc, mVarXv, mVarYc, mVarYv, mXc, mXv, mYc, mYv, NCFUNCAP, and moab::DebugOutput::tprintf().

Member Data Documentation

◆ mAreas

std::vector< double > moab::NCWriteDomain::mAreas

private

Definition at line 93 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info(), and write_values().

◆ mDimN

int moab::NCWriteDomain::mDimN

private

Definition at line 96 of file NCWriteDomain.hpp.

Referenced by init_file().

◆ mDimNi

int moab::NCWriteDomain::mDimNi

private

Definition at line 97 of file NCWriteDomain.hpp.

Referenced by init_file().

◆ mDimNj

int moab::NCWriteDomain::mDimNj

private

Definition at line 98 of file NCWriteDomain.hpp.

Referenced by init_file().

◆ mDimNv

int moab::NCWriteDomain::mDimNv

private

Definition at line 99 of file NCWriteDomain.hpp.

Referenced by init_file().

◆ mFrac

std::vector< double > moab::NCWriteDomain::mFrac

private

Definition at line 94 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info(), and write_values().

◆ mGlobalCells

long moab::NCWriteDomain::mGlobalCells

private

Definition at line 74 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info(), init_file(), and write_values().

◆ mHasAreas

bool moab::NCWriteDomain::mHasAreas

private

Definition at line 83 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info(), and write_values().

◆ mHasFrac

bool moab::NCWriteDomain::mHasFrac

private

Definition at line 85 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info().

◆ mHasMask

bool moab::NCWriteDomain::mHasMask

private

Definition at line 84 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info().

◆ mLocalCells

long moab::NCWriteDomain::mLocalCells

private

Definition at line 73 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info(), and write_values().

◆ mLocalGids

std::vector< int > moab::NCWriteDomain::mLocalGids

private

Definition at line 87 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info(), and write_values().

◆ mMask

std::vector< int > moab::NCWriteDomain::mMask

private

Definition at line 92 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info(), and write_values().

◆ mMaxCornersGlobal

int moab::NCWriteDomain::mMaxCornersGlobal

private

Definition at line 75 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info(), init_file(), and write_values().

◆ mNi

long moab::NCWriteDomain::mNi

private

On-disk grid extents. For now we always emit ni = mGlobalCells, nj = 1 — i.e. a flat layout that the CESM domain reader handles identically to the rectangular case but with j collapsed.

Definition at line 80 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info(), and init_file().

◆ mNj

long moab::NCWriteDomain::mNj

private

Definition at line 81 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info(), and init_file().

◆ mVarArea

int moab::NCWriteDomain::mVarArea

private

Definition at line 105 of file NCWriteDomain.hpp.

Referenced by init_file(), and write_values().

◆ mVarFrac

int moab::NCWriteDomain::mVarFrac

private

Definition at line 106 of file NCWriteDomain.hpp.

Referenced by init_file(), and write_values().

◆ mVarMask

int moab::NCWriteDomain::mVarMask

private

Definition at line 104 of file NCWriteDomain.hpp.

Referenced by init_file(), and write_values().

◆ mVarXc

int moab::NCWriteDomain::mVarXc

private

Definition at line 100 of file NCWriteDomain.hpp.

Referenced by init_file(), and write_values().

◆ mVarXv

int moab::NCWriteDomain::mVarXv

private

Definition at line 102 of file NCWriteDomain.hpp.

Referenced by init_file(), and write_values().

◆ mVarYc

int moab::NCWriteDomain::mVarYc

private

Definition at line 101 of file NCWriteDomain.hpp.

Referenced by init_file(), and write_values().

◆ mVarYv

int moab::NCWriteDomain::mVarYv

private

Definition at line 103 of file NCWriteDomain.hpp.

Referenced by init_file(), and write_values().

◆ mXc

std::vector< double > moab::NCWriteDomain::mXc

private

Definition at line 88 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info(), and write_values().

◆ mXv

std::vector< double > moab::NCWriteDomain::mXv

private

Definition at line 90 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info(), and write_values().

◆ mYc

std::vector< double > moab::NCWriteDomain::mYc

private

Definition at line 89 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info(), and write_values().

◆ mYv

std::vector< double > moab::NCWriteDomain::mYv

private

Definition at line 91 of file NCWriteDomain.hpp.

Referenced by collect_mesh_info(), and write_values().

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

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ NCWriteDomain()

◆ ~NCWriteDomain()

Member Function Documentation

◆ collect_mesh_info()

◆ init_file()

◆ write_nonset_variables()

◆ write_values()

Member Data Documentation

◆ mAreas

◆ mDimN

◆ mDimNi

◆ mDimNj

◆ mDimNv

◆ mFrac

◆ mGlobalCells

◆ mHasAreas

◆ mHasFrac

◆ mHasMask

◆ mLocalCells

◆ mLocalGids

◆ mMask

◆ mMaxCornersGlobal

◆ mNi

◆ mNj

◆ mVarArea

◆ mVarFrac

◆ mVarMask

◆ mVarXc

◆ mVarXv

◆ mVarYc

◆ mVarYv

◆ mXc

◆ mXv

◆ mYc

◆ mYv