Sample functions for testing remapping operations. More...

Functions
moab::ErrorCode	handleOverlapMemory (ToolContext &ctx, moab::TempestRemapper &remapper, Mesh *tempest_mesh)

moab::ErrorCode	handleOverlapMOAB (ToolContext &ctx, moab::TempestRemapper &remapper)

moab::ErrorCode	handleOverlapFiles (ToolContext &ctx, Mesh *tempest_mesh)

moab::ErrorCode	convertAndWriteMOABMesh (ToolContext &ctx, moab::TempestRemapper &remapper, Mesh *tempest_mesh)
	Convert a generated TempestRemap mesh to MOAB format and write as h5m file. More...

moab::ErrorCode	handleICOMesh (ToolContext &ctx, moab::TempestRemapper &remapper, Mesh *tempest_mesh)

moab::ErrorCode	handleRLLMesh (ToolContext &ctx, moab::TempestRemapper &remapper, Mesh *tempest_mesh)

moab::ErrorCode	handleCSMesh (ToolContext &ctx, moab::TempestRemapper &remapper, Mesh *tempest_mesh)

Variables
constexpr double	VORTEX_LON0 = 0.0

constexpr double	VORTEX_LAT0 = 0.6

constexpr double	VORTEX_R0 = 3.0

constexpr double	VORTEX_D = 5.0

constexpr double	VORTEX_T = 6.0

Detailed Description

Sample functions for testing remapping operations.

These functions provide analytical test cases with different spatial patterns for verifying remapping accuracy and performance.

Function Documentation

◆ convertAndWriteMOABMesh()

moab::ErrorCode anonymous_namespace{mbtempest.cpp}::convertAndWriteMOABMesh	(	ToolContext &	ctx,
		moab::TempestRemapper &	remapper,
		Mesh *	tempest_mesh
	)

Convert a generated TempestRemap mesh to MOAB format and write as h5m file.

When the output filename has a .h5m extension, the mesh is converted from TempestRemap format to MOAB format in memory and written as a native MOAB HDF5 file. This allows the generated meshes to be loaded by mbtempest type 5 (OVERLAP_MOAB) workflows. The TempestRemap format file is still written (with .g extension) for compatibility.

Definition at line 1775 of file mbtempest.cpp.

 {
     // Check if output filename has .h5m extension
     const std::string& outFile = ctx.outFilename;
     const size_t dot           = outFile.find_last_of( "." );
     if( dot == std::string::npos ) return moab::MB_SUCCESS;
  
     const std::string ext = outFile.substr( dot + 1 );
     if( ext != "h5m" ) return moab::MB_SUCCESS;
  
     // Register the TempestRemap mesh with the remapper as SourceMesh
     remapper.SetMesh( moab::Remapper::SourceMesh, tempest_mesh, false );
  
     // Convert TempestRemap mesh to MOAB format
     ctx.timer_push( "convert TempestRemap mesh to MOAB format" );
     MB_CHK_SET_ERR( remapper.ConvertTempestMesh( moab::Remapper::SourceMesh ),
                     "Failed to convert TempestRemap mesh to MOAB format" );
     ctx.timer_pop();
  
     // Fix degenerate quads: RLL meshes from TempestRemap have polar cells stored as
     // 4-node quads with duplicate vertices. Convert these to proper triangles so the
     // intersection algorithm can handle them correctly.
     moab::EntityHandle meshSet = remapper.GetMeshSet( moab::Remapper::SourceMesh );
     MB_CHK_SET_ERR( moab::IntxUtils::fix_degenerate_quads( ctx.mbcore, meshSet ),
                     "Failed to fix degenerate quads in converted mesh" );
     ctx.timer_push( "write MOAB mesh to h5m file" );
     MB_CHK_SET_ERR( ctx.mbcore->write_file( outFile.c_str(), nullptr, nullptr, &meshSet, 1 ),
                     "Failed to write MOAB mesh to h5m file" );
     ctx.timer_pop();
  
     if( !ctx.proc_id )
         ctx.outputFormatter.printf( 0, "Wrote MOAB mesh to %s\n", outFile.c_str() );
  
     return moab::MB_SUCCESS;
 }

References moab::TempestRemapper::ConvertTempestMesh(), moab::dot(), moab::IntxUtils::fix_degenerate_quads(), moab::TempestRemapper::GetMeshSet(), MB_CHK_SET_ERR, MB_SUCCESS, ToolContext::mbcore, ToolContext::outFilename, ToolContext::outputFormatter, moab::DebugOutput::printf(), ToolContext::proc_id, moab::TempestRemapper::SetMesh(), moab::Remapper::SourceMesh, ToolContext::timer_pop(), ToolContext::timer_push(), and moab::Core::write_file().

Referenced by handleCSMesh(), handleICOMesh(), and handleRLLMesh().

◆ handleCSMesh()

moab::ErrorCode anonymous_namespace{mbtempest.cpp}::handleCSMesh	(	ToolContext &	ctx,
		moab::TempestRemapper &	remapper,
		Mesh *	tempest_mesh
	)

Definition at line 1864 of file mbtempest.cpp.

 {
     // Generate the TempestRemap Exodus mesh (always written as .g for TempestRemap compatibility)
     std::string trFilename = ctx.outFilename;
     const size_t dot       = trFilename.find_last_of( "." );
     if( dot != std::string::npos && trFilename.substr( dot + 1 ) == "h5m" )
         trFilename = trFilename.substr( 0, dot ) + ".g";
  
     ctx.timer_push( "generate CS mesh with TempestRemap" );
     TR_CHK_SET_ERR( GenerateCSMesh( *tempest_mesh, ctx.blockSize, trFilename, "NetCDF4" ),
                     "Failed to generate CS mesh with TempestRemap" );
     ctx.timer_pop();
  
     // Add the CS mesh to the list of meshes
     ctx.meshes.push_back( tempest_mesh );
  
     // Convert and write as MOAB h5m if requested
     MB_CHK_SET_ERR( convertAndWriteMOABMesh( ctx, remapper, tempest_mesh ),
                     "Failed to convert and write MOAB mesh" );
  
     return moab::MB_SUCCESS;
 }

References ToolContext::blockSize, convertAndWriteMOABMesh(), moab::dot(), MB_CHK_SET_ERR, MB_SUCCESS, ToolContext::meshes, ToolContext::outFilename, ToolContext::timer_pop(), ToolContext::timer_push(), and TR_CHK_SET_ERR.

Referenced by CreateTempestMesh().

◆ handleICOMesh()

moab::ErrorCode anonymous_namespace{mbtempest.cpp}::handleICOMesh	(	ToolContext &	ctx,
		moab::TempestRemapper &	remapper,
		Mesh *	tempest_mesh
	)

Definition at line 1811 of file mbtempest.cpp.

 {
     std::string trFilename = ctx.outFilename;
     const size_t dot       = trFilename.find_last_of( "." );
     if( dot != std::string::npos && trFilename.substr( dot + 1 ) == "h5m" )
         trFilename = trFilename.substr( 0, dot ) + ".g";
  
     ctx.timer_push( "generate ICO mesh with TempestRemap" );
     TR_CHK_SET_ERR( GenerateICOMesh( *tempest_mesh, ctx.blockSize, ctx.computeDual, trFilename, "NetCDF4" ),
                     "Failed to generate ICO mesh with TempestRemap" );
     ctx.timer_pop();
  
     // Add the ICO mesh to the list of meshes
     ctx.meshes.push_back( tempest_mesh );
  
     MB_CHK_SET_ERR( convertAndWriteMOABMesh( ctx, remapper, tempest_mesh ),
                     "Failed to convert and write MOAB mesh" );
  
     return moab::MB_SUCCESS;
 }

References ToolContext::blockSize, ToolContext::computeDual, convertAndWriteMOABMesh(), moab::dot(), MB_CHK_SET_ERR, MB_SUCCESS, ToolContext::meshes, ToolContext::outFilename, ToolContext::timer_pop(), ToolContext::timer_push(), and TR_CHK_SET_ERR.

Referenced by CreateTempestMesh().

◆ handleOverlapFiles()

moab::ErrorCode anonymous_namespace{mbtempest.cpp}::handleOverlapFiles	(	ToolContext &	ctx,
		Mesh *	tempest_mesh
	)

Definition at line 1754 of file mbtempest.cpp.

 {
     ctx.timer_push( "create Tempest OverlapMesh" );
     TR_CHK_SET_ERR( GenerateOverlapMesh( ctx.inFilenames[0], ctx.inFilenames[1], *tempest_mesh, ctx.outFilename,
                                          "NetCDF4", "exact", true ),
                     "Failed to create Tempest OverlapMesh" );
     ctx.timer_pop();
  
     // Add the overlap mesh to the list of meshes
     ctx.meshes.push_back( tempest_mesh );
     return moab::MB_SUCCESS;
 }

References ToolContext::inFilenames, MB_SUCCESS, ToolContext::meshes, ToolContext::outFilename, ToolContext::timer_pop(), ToolContext::timer_push(), and TR_CHK_SET_ERR.

Referenced by CreateTempestMesh().

◆ handleOverlapMemory()

moab::ErrorCode anonymous_namespace{mbtempest.cpp}::handleOverlapMemory	(	ToolContext &	ctx,
		moab::TempestRemapper &	remapper,
		Mesh *	tempest_mesh
	)

Definition at line 1599 of file mbtempest.cpp.

 {
     using namespace moab;
  
     // resize the meshsets and meshes vectors
     ctx.meshsets.resize( 3 );
     ctx.meshes.resize( 3 );
  
     ctx.meshsets[0] = remapper.GetMeshSet( Remapper::SourceMesh );
     ctx.meshsets[1] = remapper.GetMeshSet( Remapper::TargetMesh );
     ctx.meshsets[2] = remapper.GetMeshSet( Remapper::OverlapMesh );
  
     // Load and process source mesh
     MB_CHK_SET_ERR( remapper.LoadMesh( Remapper::SourceMesh, ctx.inFilenames[0], TempestRemapper::DEFAULT ),
                     "Failed to load MOAB Source mesh" );
  
     // Load and process target mesh
     MB_CHK_SET_ERR( remapper.LoadMesh( Remapper::TargetMesh, ctx.inFilenames[1], TempestRemapper::DEFAULT ),
                     "Failed to load MOAB Target mesh" );
  
     // Generate overlap mesh
     TR_CHK_SET_ERR( GenerateOverlapWithMeshes( *ctx.meshes[0], *ctx.meshes[1], *tempest_mesh, "", "NetCDF4", "exact",
                                                false ),
                     "Failed to generate TempestRemap OverlapMesh" );
  
     remapper.SetMesh( Remapper::OverlapMesh, tempest_mesh );
     ctx.meshes[2] = remapper.GetMesh( Remapper::OverlapMesh );
  
     return moab::MB_SUCCESS;
 }

References moab::TempestRemapper::GetMesh(), moab::TempestRemapper::GetMeshSet(), ToolContext::inFilenames, moab::TempestRemapper::LoadMesh(), MB_CHK_SET_ERR, MB_SUCCESS, ToolContext::meshes, ToolContext::meshsets, moab::TempestRemapper::SetMesh(), and TR_CHK_SET_ERR.

Referenced by CreateTempestMesh().

◆ handleOverlapMOAB()

moab::ErrorCode anonymous_namespace{mbtempest.cpp}::handleOverlapMOAB	(	ToolContext &	ctx,
		moab::TempestRemapper &	remapper
	)

Definition at line 1630 of file mbtempest.cpp.

 {
     using namespace moab;
  
     // resize the meshsets and meshes vectors
     ctx.meshsets.resize( 3 );
     ctx.meshes.resize( 3 );
  
     ctx.meshsets[0] = remapper.GetMeshSet( Remapper::SourceMesh );
     ctx.meshsets[1] = remapper.GetMeshSet( Remapper::TargetMesh );
     ctx.meshsets[2] = remapper.GetMeshSet( Remapper::OverlapMesh );
  
     constexpr double radius_src  = 1.0;
     constexpr double radius_dest = 1.0;
  
     // Load and process target mesh
     {
         std::vector< int > metadata;
         std::string additional_read_opts_tgt = ctx.get_file_read_options( ctx.inFilenames[1] );
         if( ctx.n_procs > 1 && ctx.disc_methods[1].compare( "fv" ) != 0 )  // target discretization is cgll or dgll
         {
             // auto pcomm = new ParallelComm( ctx.mbcore, MPI_COMM_WORLD );
             // add one ghost layer to the target mesh
             // additional_read_opts_tgt = additional_read_opts_tgt +  "PARALLEL_GHOSTS=3.0.2;PARALLEL_THIN_GHOST_LAYER;SKIP_AUGMENT_WITH_GHOSTS;PRINT_PARALLEL;";
             // additional_read_opts_tgt = additional_read_opts_tgt +  "PARALLEL_COMM=1;";
             // additional_read_opts_tgt = additional_read_opts_tgt +  "PARALLEL_GHOSTS=3.0.1;";
             // additional_read_opts_tgt = additional_read_opts_tgt +  "PARALLEL_COMM=" + std::to_string(ctx.pcomm->get_id()) + ";";
         }
  
         MB_CHK_SET_ERR( remapper.LoadNativeMesh( ctx.inFilenames[1], ctx.meshsets[1], metadata,
                                                  additional_read_opts_tgt.c_str() ),
                         "Failed to load MOAB Target mesh" );
  
 #ifdef MOAB_HAVE_MPI
         if( ctx.n_procs > 1 && ctx.disc_methods[1].compare( "fv" ) != 0 &&
             false )  // target discretization is cgll or dgll
         {
             Range beforeGhost, afterGhost;
             ctx.mbcore->get_entities_by_dimension( ctx.meshsets[1], 2, beforeGhost );
  
             ctx.pcomm->set_debug_verbosity( 5 );
             MB_CHK_SET_ERR( ctx.pcomm->exchange_ghost_cells( 2, 0, 1, 0, true, true, &ctx.meshsets[1] ),
                             "Failed to exchange ghost cells for MOAB Target mesh" );
             ctx.pcomm->set_debug_verbosity( 0 );
  
             ctx.mbcore->get_entities_by_dimension( ctx.meshsets[1], 2, afterGhost );
             std::cout << ctx.proc_id << ": N(before) = " << beforeGhost.size() << ", N(after) = " << afterGhost.size()
                       << std::endl;
  
             std::vector< Tag > taglist;
             taglist.push_back( ctx.mbcore->globalId_tag() );
             Tag gdofTag;
             MB_CHK_SET_ERR( ctx.mbcore->tag_get_handle( "GLOBAL_DOFS", gdofTag ),
                             "Failed to get global dofs tag for MOAB Target mesh" );
             taglist.push_back( gdofTag );
             MB_CHK_SET_ERR( ctx.pcomm->exchange_tags( taglist, taglist, afterGhost ),
                             "Failed to exchange global dofs for MOAB Target mesh" );
             // std::set< unsigned int > commprocs;
             // MB_CHK_SET_ERR( ctx.pcomm->get_comm_procs( commprocs ),
             //                 "Failed to get commprocs for MOAB Target mesh" );
             // if (ctx.proc_id == 0)
             // {
             //     std::cout << ctx.proc_id << ": commprocs = [";
             //     for( auto p : commprocs ) std::cout << p << ", ";
             //     std::cout << "]\n";
  
             //     std::cout << ctx.proc_id << ": N(after) = " << afterGhost.size() << std::endl;
             //     for (auto eh: afterGhost)
             //     {
             //         std::cout << ctx.mbcore->type_from_handle(eh) << ": " << eh << std::endl;
             //     }
             // }
         }
 #endif
  
         if( !metadata.empty() )
         {
             remapper.SetMeshType( Remapper::TargetMesh, metadata );
         }
  
         MB_CHK_SET_ERR( IntxUtils::ScaleToRadius( ctx.mbcore, ctx.meshsets[1], radius_dest ),
                         "Failed to preprocess MOAB Target mesh" );
     }
  
     // Load and process source mesh
     {
         std::vector< int > metadata;
         auto additional_read_opts_src = ctx.get_file_read_options( ctx.inFilenames[0] );
 #ifdef MOAB_HAVE_MPI
         if( ctx.n_procs > 1 )
         {
             // auto pcomm = new ParallelComm( ctx.mbcore, MPI_COMM_WORLD );
             additional_read_opts_src =
                 additional_read_opts_src + "PARALLEL_COMM=" + std::to_string( ctx.pcomm->get_id() ) + ";";
         }
 #endif
         MB_CHK_SET_ERR( remapper.LoadNativeMesh( ctx.inFilenames[0], ctx.meshsets[0], metadata,
                                                  additional_read_opts_src.c_str() ),
                         "Failed to load MOAB Source mesh" );
  
         if( !metadata.empty() )
         {
             remapper.SetMeshType( Remapper::SourceMesh, metadata );
         }
  
         MB_CHK_SET_ERR( IntxUtils::ScaleToRadius( ctx.mbcore, ctx.meshsets[0], radius_src ),
                         "Failed to preprocess MOAB Source mesh" );
     }
  
     if( ctx.computeWeights )
     {
         // Convert MOAB to TempestRemap meshes
         MB_CHK_SET_ERR( remapper.ConvertMeshToTempest( Remapper::SourceMesh ),
                         "Failed to convert MOAB Source mesh to TempestRemap mesh" );
         ctx.meshes[0] = remapper.GetMesh( Remapper::SourceMesh );
  
         MB_CHK_SET_ERR( remapper.ConvertMeshToTempest( Remapper::TargetMesh ),
                         "Failed to convert MOAB Target mesh to TempestRemap mesh" );
         ctx.meshes[1] = remapper.GetMesh( Remapper::TargetMesh );
     }
  
     return moab::MB_SUCCESS;
 }

References ToolContext::computeWeights, moab::TempestRemapper::ConvertMeshToTempest(), ToolContext::disc_methods, moab::Core::get_entities_by_dimension(), ToolContext::get_file_read_options(), moab::TempestRemapper::GetMesh(), moab::TempestRemapper::GetMeshSet(), moab::Core::globalId_tag(), ToolContext::inFilenames, moab::Remapper::LoadNativeMesh(), MB_CHK_SET_ERR, MB_SUCCESS, ToolContext::mbcore, ToolContext::meshes, ToolContext::meshsets, ToolContext::n_procs, ToolContext::proc_id, moab::TempestRemapper::SetMeshType(), moab::Range::size(), and moab::Core::tag_get_handle().

Referenced by CreateTempestMesh().

◆ handleRLLMesh()

moab::ErrorCode anonymous_namespace{mbtempest.cpp}::handleRLLMesh	(	ToolContext &	ctx,
		moab::TempestRemapper &	remapper,
		Mesh *	tempest_mesh
	)

Definition at line 1832 of file mbtempest.cpp.

 {
     std::string trFilename = ctx.outFilename;
     const size_t dot       = trFilename.find_last_of( "." );
     if( dot != std::string::npos && trFilename.substr( dot + 1 ) == "h5m" )
         trFilename = trFilename.substr( 0, dot ) + ".g";
  
     ctx.timer_push( "generate RLL mesh with TempestRemap" );
     TR_CHK_SET_ERR( GenerateRLLMesh( *tempest_mesh,                     // Mesh& meshOut,
                                      ctx.blockSize * 2, ctx.blockSize,  // int nLongitudes, int nLatitudes,
                                      0.0, 360.0,                        // double dLonBegin, double dLonEnd,
                                      -90.0, 90.0,                       // double dLatBegin, double dLatEnd,
                                      false, false, false,  // bool fGlobalCap, bool fFlipLatLon, bool fForceGlobal,
                                      "" /*ctx.inFilename*/,
                                      "",             // std::string strInputFile, std::string strInputFileLonName
                                      "",             // std::string strInputFileLatName
                                      trFilename,     // std::string strOutputFile
                                      "NetCDF4",      // std::string strOutputFormat
                                      true            // bool fVerbose
                                      ),
                     "Failed to generate RLL mesh with TempestRemap" );
     ctx.timer_pop();
  
     // Add the RLL mesh to the list of meshes
     ctx.meshes.push_back( tempest_mesh );
  
     MB_CHK_SET_ERR( convertAndWriteMOABMesh( ctx, remapper, tempest_mesh ),
                     "Failed to convert and write MOAB mesh" );
  
     return moab::MB_SUCCESS;
 }