Context class for MOAB-TempestRemap tool configuration and state management. More...

Collaboration diagram for ToolContext:

Public Member Functions
	ToolContext (moab::Core *icore)
	Construct a new ToolContext object with MPI support. More...

	~ToolContext ()=default

	ToolContext (const ToolContext &)=delete

ToolContext &	operator= (const ToolContext &)=delete

	ToolContext (ToolContext &&)=delete

ToolContext &	operator= (ToolContext &&)=delete

void	timer_push (const std::string &operation)
	Start timing an operation. More...

void	timer_pop ()
	Stop timing and log the operation duration. More...

moab::ErrorCode	ParseCLOptions (int argc, char **argv)
	Parse command line arguments. More...

std::string	get_file_read_options (const std::string &filename)
	Get the appropriate MOAB read options based on file extension and parallel configuration. More...

Public Attributes
moab::Core *const	mbcore
	MOAB Core instance for mesh operations. More...

const int	proc_id
	MPI process rank (0 for serial) More...

const int	n_procs
	Total number of MPI processes (1 for serial) More...

moab::DebugOutput	outputFormatter
	Formatter for debug output. More...

moab::TempestRemapper::TempestMeshType	meshType { moab::TempestRemapper::DEFAULT }
	Type of mesh to generate. More...

std::vector< std::string >	inFilenames
	Input filenames for source and target meshes. More...

std::vector< int >	disc_orders
	Discretization orders for source and target. More...

std::vector< std::string >	disc_methods
	Discretization methods (fv, cgll, dgll) for source and target. More...

std::vector< std::string >	doftag_names
	Degree of freedom tag names for source and target. More...

std::string	outFilename { "outputFile.nc" }
	Output filename for remapping results. More...

std::string	intxFilename
	Intersection mesh filename (optional) More...

std::string	baselineFile
	Baseline file for verification (optional) More...

std::string	variableToVerify
	Variable name for verification (optional) More...

std::string	fvMethod { "none" }
	Finite volume method specification. More...

GenerateOfflineMapAlgorithmOptions	mapOptions
	Configuration for offline map generation. More...

moab::TempestOnlineMap::CAASType	cassType
	Conservative and accurate advection scheme type. More...

int	ensureMonotonicity { 0 }
	Monotonicity enforcement level (0=none, 1=basic, 2=full, 3=strict) More...

bool	rrmGrids { false }
	Flag to use RRM (Regional Refinement Meshes) More...

bool	kdtreeSearch { true }
	Enable KD-tree for spatial searches. More...

bool	fCheck { false }
	Enable additional checking during remapping. More...

bool	fVolumetric { false }
	Enable volumetric (3D) remapping. More...

bool	useGnomonicProjection { false }
	Use gnomonic projection for certain operations. More...

bool	print_diagnostics { false }
	Print detailed diagnostic information. More...

bool	skip_intersection { false }
	Skip intersection computation (for debugging) More...

double	boxeps { 1e-7 }
	Epsilon for bounding box checks. More...

double	epsrel { ReferenceTolerance }
	Relative tolerance for convergence. More...

bool	skip_io { false }
	Skip file I/O operations (for testing) More...

bool	computeDual { false }
	Compute dual mesh. More...

bool	computeWeights { false }
	Compute interpolation weights. More...

bool	verifyConservation { false }
	Verify conservation properties. More...

bool	verifyWeights { false }
	Verify interpolation weights. More...

bool	enforceConvexity { false }
	Enforce convexity in mesh elements. More...

std::unique_ptr< moab::CpuTimer >	timer
	Timer for performance measurement. More...

double	timer_ops { 0.0 }
	Operation timer value. More...

std::string	opName
	Name of current operation being timed. More...

int	nlayers { 0 }
	Number of ghost layers for parallel operations. More...

int	blockSize { 5 }
	Block size for vectorized operations. More...

std::vector< Mesh * >	meshes
	Collection of TempestRemap meshes. More...

std::vector< moab::EntityHandle >	meshsets
	MOAB entity sets for meshes. More...

Private Member Functions
void	printHelp (const char *progName) const
	Print detailed help message with usage examples. More...

std::string	getMeshTypeName () const
	Get mesh type as string. More...

void	processMeshOptions (ProgOptions &opts)
	Process mesh options from command line. More...

void	printRuntimeParameters () const
	Print all runtime parameters in a formatted way. More...

void	configureMapOptions (int nlayer_input)
	Configure map options based on command line parameters. More...

Detailed Description

Context class for MOAB-TempestRemap tool configuration and state management.

Definition at line 95 of file mbtempest.cpp.

Constructor & Destructor Documentation

◆ ToolContext() [1/3]

ToolContext::ToolContext ( moab::Core * icore )

inlineexplicit

Construct a new ToolContext object with MPI support.

Parameters

icore	MOAB Core instance (must not be null)
p_pcomm	Parallel communicator (must not be null in MPI mode)

Exceptions

std::invalid_argument if icore is null or p_pcomm is null in MPI mode

Construct a new ToolContext object (serial version)

Parameters

icore MOAB Core instance (must not be null)

Exceptions

std::invalid_argument if icore is null

Definition at line 172 of file mbtempest.cpp.

         : mbcore( icore ), proc_id( 0 ), n_procs( 1 ), outputFormatter( std::cout, 0, 0 )
     {
 #endif
         // Initialize default values
         inFilenames.reserve( 2 );
         doftag_names = { "GLOBAL_ID", "GLOBAL_ID" };
         disc_orders  = { 1, 1 };
         disc_methods = { "fv", "fv" };
  
         // Initialize timer and output formatter
         timer = std::make_unique< moab::CpuTimer >();
         outputFormatter.set_prefix( "[MBTempest]: " );
  
         // Set default map options
         mapOptions.fNoConservation = false;
         mapOptions.fMonotone       = false;
         mapOptions.fNoCorrectAreas = false;
         mapOptions.fNoCheck        = false;
         mapOptions.nPin            = 1;
         mapOptions.nPout           = 1;
     }

References disc_methods, disc_orders, doftag_names, inFilenames, mapOptions, outputFormatter, moab::DebugOutput::set_prefix(), and timer.

Referenced by main().

◆ ~ToolContext()

ToolContext::~ToolContext ( )

default

◆ ToolContext() [2/3]

ToolContext::ToolContext ( const ToolContext & )

delete

◆ ToolContext() [3/3]

ToolContext::ToolContext ( ToolContext && )

delete

Member Function Documentation

◆ configureMapOptions()

void ToolContext::configureMapOptions ( int nlayer_input )

inlineprivate

Configure map options based on command line parameters.

Parameters

nlayer_input Number of ghost layers

Definition at line 837 of file mbtempest.cpp.

     {
         // Set polynomial orders with bounds checking
         this->mapOptions.nPin  = ( this->disc_orders.empty() ) ? 1 : this->disc_orders[0];
         this->mapOptions.nPout = ( this->disc_orders.size() > 1 ) ? this->disc_orders[1] : this->mapOptions.nPin;
  
         // Initialize flags
         this->mapOptions.fSourceConcave = false;
         this->mapOptions.fTargetConcave = false;
         this->mapOptions.strMethod.clear();
  
         // Configure finite volume method if specified
         if( this->fvMethod != "none" )
         {
             this->mapOptions.strMethod       = this->fvMethod + ";";
             this->mapOptions.fNoConservation = true;
         }
  
         // Configure monotonicity with validation
         this->ensureMonotonicity = std::max( 0, std::min( 3, this->ensureMonotonicity ) );  // Clamp to 0-3
         switch( this->ensureMonotonicity )
         {
             case 0:
                 this->mapOptions.fMonotone = false;
                 break;
             case 3:
                 this->mapOptions.strMethod += "mono3;";
                 this->mapOptions.fMonotone = true;
                 break;
             case 2:
                 this->mapOptions.strMethod += "mono2;";
                 this->mapOptions.fMonotone = true;
                 break;
             case 1:
             default:
                 this->mapOptions.fMonotone = true;
                 break;
         }
  
         // Set other options
         this->mapOptions.fNoCorrectAreas = false;
         this->mapOptions.fNoCheck        = !this->fCheck;
  
         // Add volumetric flag if needed
         if( this->fVolumetric )
         {
             this->mapOptions.strMethod += "volumetric;";
         }
  
         // Set number of ghost layers based on method and order.
         // FV order 1 needs 0 ghost layers; FV order p > 1 needs p+1 ghost layers.
         if( this->fvMethod == "delaunay" || this->fvMethod == "bilin" )
         {
             this->skip_intersection = true;
             this->nlayers           = 3;  // conservative
         }
         else
         {
             // order 1: no ghost layers
             // order p: p+1 layers (again, being conservative)
             this->nlayers = ( this->mapOptions.nPin > 1 ) ? this->mapOptions.nPin + 1 : 0;
         }
  
         // User-supplied value always overrides the internal default (even 0 is valid).
         if( nlayer_input >= 0 )
         {
             this->nlayers = nlayer_input;
         }
  
         // Configure output
         this->mapOptions.strOutputMapFile = this->outFilename;
         this->mapOptions.strOutputFormat  = "Netcdf4";
     }

References ensureMonotonicity, fCheck, fvMethod, fVolumetric, nlayers, outFilename, and skip_intersection.

Referenced by ParseCLOptions().

◆ get_file_read_options()

std::string ToolContext::get_file_read_options ( const std::string & filename )

inline

Get the appropriate MOAB read options based on file extension and parallel configuration.

Parameters

ctx	Tool context containing parallel information
filename	Input filename to determine read options

Returns: std::string MOAB read options string

Definition at line 489 of file mbtempest.cpp.

     {
         // For serial execution, return default options
         if( n_procs <= 1 )
         {
             return "";
         }
  
         // Extract file extension
         const size_t last_dot = filename.find_last_of( "." );
         if( last_dot == std::string::npos )
         {
             return "";  // No extension found
         }
  
         const std::string extension = filename.substr( last_dot + 1 );
  
         // Handle H5M files
         if( extension == "h5m" )
         {
             return "PARALLEL=READ_PART;PARTITION=PARALLEL_PARTITION;PARALLEL_RESOLVE_SHARED_ENTS;";
         }
  
         // Handle NetCDF files
         if( extension == "nc" )
         {
             // Default NetCDF options
 #ifdef MOAB_HAVE_ZOLTAN
             std::string netcdf_options = "PARALLEL=READ_PART;PARTITION_METHOD=RCBZOLTAN;";
 #else
             std::string netcdf_options = "PARALLEL=READ_PART;PARTITION_METHOD=TRIVIAL;";
 #endif
             // Only rank 0 needs to determine the NetCDF file type
             if( proc_id == 0 )
             {
                 NcFile ncFile( filename.c_str(), NcFile::ReadOnly );
                 if( !ncFile.is_valid() )
                 {
                     // Handle invalid file
                     return netcdf_options;
                 }
  
                 // Check for different NetCDF formats
                 int format_flags = 0;
                 for( int i = 0; i < ncFile.num_dims(); i++ )
                 {
                     const std::string dim_name = ncFile.get_dim( i )->name();
  
                     if( dim_name == "grid_size" || dim_name == "grid_corners" || dim_name == "grid_rank" )
                     {
                         format_flags |= 1;  // SCRIP format
                     }
                     else if( dim_name == "nodeCount" || dim_name == "elementCount" || dim_name == "maxNodePElement" )
                     {
                         format_flags |= 2;  // ESMF format
                     }
                     else if( dim_name == "nCells" || dim_name == "nEdges" || dim_name == "nVertices" ||
                              dim_name == "vertexDegree" )
                     {
                         format_flags |= 4;  // MPAS format
                     }
                 }
  
                 // Apply format-specific options
                 if( format_flags & 2 )
                 {  // ESMF format
                     netcdf_options += "PARALLEL_RESOLVE_SHARED_ENTS;VARIABLE=;";
                 }
                 else if( format_flags & 1 )
                 {                          // SCRIP format
                     netcdf_options += "";  // no extra options necessary for now
                 }
                 else if( format_flags & 4 )
                 {  // MPAS format
                     netcdf_options += "PARALLEL_RESOLVE_SHARED_ENTS;NO_EDGES;NO_MIXED_ELEMENTS;VARIABLE=;";
                 }
             }
  
             // Broadcast the options to all processes
 #ifdef MOAB_HAVE_MPI
             int line_size = netcdf_options.size();
             MPI_Bcast( &line_size, 1, MPI_INT, 0, MPI_COMM_WORLD );
             if( proc_id != 0 )
             {
                 netcdf_options.resize( line_size );
             }
             MPI_Bcast( const_cast< char* >( netcdf_options.data() ), line_size, MPI_CHAR, 0, MPI_COMM_WORLD );
 #endif
  
             return netcdf_options;
         }
  
         // Default options for other file types
         return "PARALLEL=BCAST_DELETE;PARTITION=TRIVIAL;PARALLEL_RESOLVE_SHARED_ENTS;";
     }

References n_procs, ncFile, and proc_id.

Referenced by anonymous_namespace{mbtempest.cpp}::handleOverlapMOAB().

◆ getMeshTypeName()

std::string ToolContext::getMeshTypeName ( ) const

inlineprivate

Get mesh type as string.

Returns: String representation of mesh type

Definition at line 646 of file mbtempest.cpp.

     {
         switch( this->meshType )
         {
             case moab::TempestRemapper::CS:
                 return "Cubed-Sphere";
             case moab::TempestRemapper::RLL:
                 return "Latitude-Longitude";
             case moab::TempestRemapper::ICO:
                 return "Icosahedral";
             case moab::TempestRemapper::OVERLAP_FILES:
                 return "Overlap (files)";
             case moab::TempestRemapper::OVERLAP_MEMORY:
                 return "Overlap (memory)";
             case moab::TempestRemapper::OVERLAP_MOAB:
                 return "Overlap (MOAB)";
             default:
                 return "Unknown";
         }
     }

References moab::TempestRemapper::CS, moab::TempestRemapper::ICO, meshType, moab::TempestRemapper::OVERLAP_FILES, moab::TempestRemapper::OVERLAP_MEMORY, moab::TempestRemapper::OVERLAP_MOAB, and moab::TempestRemapper::RLL.

Referenced by printRuntimeParameters().

◆ operator=() [1/2]

ToolContext& ToolContext::operator= ( const ToolContext & )

delete

◆ operator=() [2/2]

ToolContext& ToolContext::operator= ( ToolContext && )

delete

◆ ParseCLOptions()

moab::ErrorCode ToolContext::ParseCLOptions	(	int	argc,
		char **	argv
	)

inline

Parse command line arguments.

Parameters

argc	Argument count
argv	Argument values

Returns: moab::ErrorCode indicating success or failure

Exceptions

std::invalid_argument for invalid command line arguments

Definition at line 242 of file mbtempest.cpp.

     {
         // Initialize variables for command line options
         int imeshType                  = 0;
         std::string expectedFName      = "output.exo";
         std::string expectedMethod     = "fv";
         std::string expectedFVMethod   = "none";
         std::string expectedDofTagName = "GLOBAL_ID";
         int expectedOrder              = 1;
         int useCAAS                    = 0;
         int nlayer_input               = -1;  // -1 means not set by user
         bool version_info              = false;
  
         // Print command line for debugging
         if( proc_id == 0 )
         {
             std::cout << "Command line options provided to mbtempest:\n  ";
             for( int i = 0; i < argc; ++i )
             {
                 std::cout << argv[i] << " ";
             }
             std::cout << "\n" << std::endl;
         }
  
         // Create options object with description
         ProgOptions opts( "mbtempest - A mesh generation and remapping tool" );
  
         // Mesh generation options
         opts.addOpt< int >( "type,t",
                             "Type of mesh (default=CS; Choose from [CS=0, RLL=1, ICO=2, OVERLAP_FILES=3, "
                             "OVERLAP_MEMORY=4, OVERLAP_MOAB=5])",
                             &imeshType );
  
         opts.addOpt< int >( "res,r", "Resolution of the mesh (default=5)", &blockSize );
  
         opts.addOpt< void >( "dual,d", "Output the dual of the mesh (relevant only for ICO mesh type)", &computeDual );
  
         opts.addOpt< std::string >( "file,f", "Output computed mesh or remapping weights to specified filename",
                                     &outFilename );
  
         // Input/Output options
         opts.addOpt< std::string >(
             "load,l", "Input mesh filenames for source and target meshes. (relevant only when computing weights)",
             &expectedFName );
  
         opts.addOpt< void >( "advfront,a",
                              "Use the advancing front intersection instead of the Kd-tree based algorithm to compute "
                              "mesh intersections.",
                              &kdtreeSearch );
  
         opts.addOpt< std::string >( "intx,i", "Output TempestRemap intersection mesh filename", &intxFilename );
  
         opts.addOpt< void >(
             "weights,w",
             "Compute and output the weights using the overlap mesh (generally relevant only for OVERLAP mesh)",
             &computeWeights );
  
         // Discretization options
         opts.addOpt< void >(
             "verbose,v", "Print verbose diagnostic messages during intersection and map computation (default=false)",
             &print_diagnostics );
  
         opts.addOpt< std::string >( "method,m", "Discretization method for the source and target solution fields",
                                     &expectedMethod );
  
         opts.addOpt< int >( "order,o", "Discretization orders for the source and target solution fields",
                             &expectedOrder );
  
         opts.addOpt< std::string >( "global_id,g",
                                     "Tag name that contains the global DoF IDs for source and target solution fields",
                                     &expectedDofTagName );
  
         // Advanced options
         opts.addOpt< std::string >( "fvmethod",
                                     "Sub-type method for FV-FV projections (invdist, delaunay, bilin, intbilin, "
                                     "intbilingb, none. Default: none)",
                                     &expectedFVMethod );
  
         opts.addOpt< void >(
             "noconserve", "Do not apply conservation to the resultant weights (relevant only when computing weights)",
             &mapOptions.fNoConservation );
  
         opts.addOpt< void >(
             "volumetric", "Apply a volumetric projection to compute the weights (relevant only when computing weights)",
             &fVolumetric );
  
         opts.addOpt< void >( "skip_intersection", "Skip mesh intersection computation.", &skip_intersection );
  
         opts.addOpt< void >( "skip_output", "For performance studies, skip all I/O operations.", &skip_io );
  
         opts.addOpt< void >( "gnomonic", "Use Gnomonic plane projections to compute coverage mesh.",
                              &useGnomonicProjection );
  
         opts.addOpt< void >( "enforce_convexity", "Check convexity of input meshes to compute mesh intersections",
                              &enforceConvexity );
  
         opts.addOpt< void >( "nobubble", "Do not use bubble on interior of spectral element nodes",
                              &mapOptions.fNoBubble );
  
         opts.addOpt< void >(
             "sparseconstraints",
             "Use sparse solver for constraints when we have high-valence (typical with high-res RLL mesh)",
             &mapOptions.fSparseConstraints );
  
         opts.addOpt< void >(
             "rrmgrids",
             "At least one of the meshes is a regionally refined grid (relevant to accelerate intersection computation)",
             &rrmGrids );
  
         opts.addOpt< void >( "checkmap", "Check the generated map for conservation and consistency", &fCheck );
  
         opts.addOpt< void >( "verify",
                              "Verify the accuracy of the maps by projecting analytical functions from source to target "
                              "grid by applying the maps",
                              &verifyWeights );
  
         opts.addOpt< std::string >( "var",
                                     "Tag name of the variable to use in the verification study (error metrics for user "
                                     "defined variables may not be available)",
                                     &variableToVerify );
  
         opts.addOpt< int >( "monotonicity", "Ensure monotonicity in the weight generation. Options=[0,1,2,3]",
                             &ensureMonotonicity );
  
         opts.addOpt< int >( "ghost",
                             "Number of ghost layers in coverage mesh (overrides automatic selection: 0 for FV order 1, "
                             "p+1 for FV order p>1)",
                             &nlayer_input );
  
         opts.addOpt< double >( "boxeps", "The tolerance for boxes (default=1e-7)", &boxeps );
  
         opts.addOpt< int >( "limiter", "Apply nonlinear filter after linear map application", &useCAAS );
  
         opts.addOpt< std::string >( "baseline", "Output baseline file", &baselineFile );
  
         opts.addOpt< void >( "manual", "Show documentation about usage with examples" );
  
         opts.addOpt< void >( "version", "Show version information", &version_info );
  
         // Parse command line
         opts.parseCommandLine( argc, argv );
  
         // Handle call for detailed information
         if( opts.numOptSet( "manual" ) > 0 )
         {
             if( this->proc_id == 0 )
             {
                 this->printHelp( argv[0] );
             }
             exit( 0 );
         }
  
         if( version_info )
         {
             if( this->proc_id == 0 )
             {
                 std::cout << "mbtempest is part of the MOAB library version " << std::string( MOAB_PACKAGE_VERSION )
                           << "\n";
             }
             exit( 0 );
         }
  
         // Process mesh type
         switch( imeshType )
         {
             case 0:
                 this->meshType = moab::TempestRemapper::CS;
                 break;
             case 1:
                 this->meshType = moab::TempestRemapper::RLL;
                 break;
             case 2:
                 this->meshType = moab::TempestRemapper::ICO;
                 break;
             case 3:
                 this->meshType = moab::TempestRemapper::OVERLAP_FILES;
                 break;
             case 4:
                 this->meshType = moab::TempestRemapper::OVERLAP_MEMORY;
                 break;
             case 5:
                 this->meshType = moab::TempestRemapper::OVERLAP_MOAB;
                 break;
             default:
                 this->meshType = moab::TempestRemapper::DEFAULT;
                 break;
         }
  
         // Process CAAS type
         switch( useCAAS )
         {
             case 1:
                 this->cassType = moab::TempestOnlineMap::CAAS_GLOBAL;
                 break;
             case 2:
                 this->cassType = moab::TempestOnlineMap::CAAS_LOCAL;
                 break;
             case 3:
                 this->cassType = moab::TempestOnlineMap::CAAS_LOCAL_ADJACENT;
                 break;
             case 4:
                 this->cassType = moab::TempestOnlineMap::CAAS_QLT;
                 break;
             default:
                 this->cassType = moab::TempestOnlineMap::CAAS_NONE;
                 break;
         }
  
         // Process input files if provided
         if( !expectedFName.empty() )
         {
             this->inFilenames = { expectedFName };
         }
  
         // Process discretization options through processMeshOptions to handle both single and multiple values
         // Set initial defaults that can be overridden by processMeshOptions
         this->fvMethod     = expectedFVMethod;
         this->disc_orders  = { expectedOrder, expectedOrder };
         this->disc_methods = { expectedMethod, expectedMethod };
         this->doftag_names = { expectedDofTagName, expectedDofTagName };
  
         // Let processMeshOptions handle all the discretization option processing
         this->processMeshOptions( opts );
  
         // Now use the processed values for map configuration
         this->mapOptions.nPin           = this->disc_orders[0];
         this->mapOptions.nPout          = this->disc_orders[1];
         this->mapOptions.fSourceConcave = false;
         this->mapOptions.fTargetConcave = false;
         this->mapOptions.strMethod      = "";
  
         // Configure map options with the processed values - this handles all remaining setup
         this->configureMapOptions( nlayer_input );
  
         // Print runtime parameters
         this->printRuntimeParameters();
  
         return moab::MB_SUCCESS;
     }

References ProgOptions::addOpt(), baselineFile, blockSize, boxeps, moab::TempestOnlineMap::CAAS_GLOBAL, moab::TempestOnlineMap::CAAS_LOCAL, moab::TempestOnlineMap::CAAS_LOCAL_ADJACENT, moab::TempestOnlineMap::CAAS_NONE, moab::TempestOnlineMap::CAAS_QLT, cassType, computeDual, computeWeights, configureMapOptions(), moab::TempestRemapper::CS, moab::TempestRemapper::DEFAULT, enforceConvexity, ensureMonotonicity, fCheck, fvMethod, fVolumetric, moab::TempestRemapper::ICO, intxFilename, kdtreeSearch, mapOptions, MB_SUCCESS, meshType, MOAB_PACKAGE_VERSION, ProgOptions::numOptSet(), outFilename, moab::TempestRemapper::OVERLAP_FILES, moab::TempestRemapper::OVERLAP_MEMORY, moab::TempestRemapper::OVERLAP_MOAB, ProgOptions::parseCommandLine(), print_diagnostics, printHelp(), printRuntimeParameters(), proc_id, processMeshOptions(), moab::TempestRemapper::RLL, rrmGrids, skip_intersection, skip_io, useGnomonicProjection, variableToVerify, and verifyWeights.

Referenced by main().

◆ printHelp()

void ToolContext::printHelp ( const char * progName ) const

inlineprivate

Print detailed help message with usage examples.

Parameters

progName Program name

Definition at line 590 of file mbtempest.cpp.

     {
         if( this->proc_id != 0 ) return;
  
         std::cout << "MOAB-Tempest: A mesh generation and remapping tool\n"
                   << "==================================================\n\n"
                   << "Usage: " << progName << " [OPTIONS]\n\n"
                   << "Mesh Generation Options:\n"
                   << "  -t, --type TYPE       Type of mesh to generate (required for mesh generation):\n"
                   << "                           0 = Cubed-Sphere (CS)\n"
                   << "                           1 = Regular Latitude-Longitude (RLL)\n"
                   << "                           2 = Icosahedral (ICO)\n"
                   << "                           3 = TempestRemap overlap (thin interface))\n"
                   << "                           4 = MOAB with TempestRemap overlap in memory\n"
                   << "                           5 = Parallel handling of Overlap meshes with MOAB (recommended)\n\n"
                   << "  -r, --res N           Resolution (number of elements on edge, default: 10)\n"
                   << "  -f, --file FILE       Output filename (default: output.h5m)\n\n"
                   << "Discretization Options:\n"
                   << "  -m, --method METHOD   Discretization method (default: fv):\n"
                   << "                           fv   = Finite Volume\n"
                   << "                           cgll = Continuous Galerkin with Legendre-Gauss-Lobatto\n"
                   << "                           dgll = Discontinuous Galerkin with Legendre-Gauss-Lobatto\n\n"
                   << "  -o, --order N         Discretization order (default: 1, range: 1-4)\n\n"
                   << "Remapping Options:\n"
                   << "  --mono N              Monotonicity constraints (default: 0):\n"
                   << "                           0 = No monotonicity\n"
                   << "                           1 = Basic monotonicity\n"
                   << "                           2 = Full monotonicity with bounds\n"
                   << "                           3 = Strict monotonicity\n\n"
                   << "  --limiter TYPE        Nonlinear limiting (optional):\n"
                   << "                           none = No limiting (default)\n"
                   << "                           global = Global CAAS limiting\n"
                   << "                           local = Localized CAAS limiting\n"
                   << "                           qlt = Quasi-Local Tree-based limiting\n\n"
                   << "Input/Output Options:\n"
                   << "  -l, --load FILE       Load input mesh file (use twice for source and target)\n"
                   << "  -i, --global_id TAG   Global ID tag name (default: GLOBAL_ID)\n"
                   << "  --diagnostics         Print diagnostic information\n\n"
                   << "Miscellaneous Options:\n"
                   << "  --manual              Show this help message and exit\n"
                   << "  --version             Show version information\n\n"
                   << "Examples:\n"
                   << "  # Generate a cubed-sphere mesh with resolution 25\n"
                   << "  " << progName << " --type 0 --res 25 -f cs_mesh.h5m\n\n"
                   << "  # Generate a latitude-longitude mesh with resolution 180\n"
                   << "  " << progName << " --type 1 --res 180 -f rll_mesh.h5m\n\n"
                   << "  # Create a map between two meshes with order 4\n"
                   << "  " << progName << " --type 5 --load source_mesh.h5m --load target_mesh.h5m \\\n"
                   << "      --method cgll --order 4 --global_id GLOBAL_DOFS \\\n"
                   << "      --method fv --order 1 --limiter 1 --file map.nc\n";
     }

Referenced by ParseCLOptions().

◆ printRuntimeParameters()

void ToolContext::printRuntimeParameters ( ) const

inlineprivate

Print all runtime parameters in a formatted way.

Definition at line 768 of file mbtempest.cpp.

     {
         if( this->proc_id != 0 ) return;
  
         constexpr int width = 60;
  
         std::cout << std::string( width, '=' ) << "\n";
         std::cout << "  MOAB-TempestRemap Runtime Configuration " << "\n";
         std::cout << std::string( width, '=' );
  
         // Input files
         if( this->meshType == moab::TempestRemapper::OVERLAP_MOAB )
         {
             if( !this->inFilenames.empty() )
             {
                 std::cout << "\n\nInput Files:";
                 std::cout << "\n  Source mesh:          " << this->inFilenames[0];
                 std::cout << "\n  Target mesh:          " << this->inFilenames[1];
             }
  
             std::cout << "\n\nOutput Files:";
             if( !skip_intersection )
                 std::cout << "\n  Intersection mesh:    "
                           << ( this->computeWeights ? this->intxFilename : this->outFilename );
             if( computeWeights ) std::cout << "\n  Remap weights:        " << this->outFilename;
         }
  
         // Mesh configuration
         std::cout << "\n\nMesh Configuration:";
         std::cout << "\n  Mesh type:              " << this->getMeshTypeName();
         if( this->meshType <= moab::TempestRemapper::ICO )
             std::cout << "\n  Resolution:             " << this->blockSize;
         if( this->meshType == moab::TempestRemapper::ICO && computeDual )
             std::cout << "\n  Compute dual:           " << ( this->computeDual ? "Yes" : "No" );
  
         if( computeWeights )
         {
             std::cout << "\n  Gnomonic projection:    " << ( this->useGnomonicProjection ? "Yes" : "No" );
             std::cout << "\n  Intersection algorithm: " << ( this->kdtreeSearch ? "KdTree search" : "Advancing front" );
  
             // Discretization settings
             std::cout << "\n\nDiscretization:";
             std::cout << "\n  Source:             " << this->disc_methods[0] << " (order " << this->disc_orders[0]
                       << ")";
             std::cout << "\n  Target:             " << this->disc_methods[1] << " (order " << this->disc_orders[1]
                       << ")";
  
             // Remapping options
             std::cout << "\n\nRemapping Options:";
             std::cout << "\n  Method:             "
                       << ( this->mapOptions.strMethod.empty() ? "Default" : this->mapOptions.strMethod );
             std::cout << "\n  Monotonicity:       " << ( this->ensureMonotonicity ? "Yes" : "No" );
             std::cout << "\n  Volumetric:         " << ( this->fVolumetric ? "Yes" : "No" );
             std::cout << "\n  Check consistency:  " << ( this->fCheck ? "Yes" : "No" );
             std::cout << "\n  Skip intersection:  " << ( this->skip_intersection ? "Yes" : "No" );
         }
  
         // Parallel configuration
         std::cout << "\n\nParallel Configuration:";
         std::cout << "\n  MPI Processes:          " << this->n_procs;
         if( this->meshType > moab::TempestRemapper::ICO ) std::cout << "\n  Number of Ghost Layers: " << this->nlayers;
  
         std::cout << "\n\n" << std::string( width, '=' ) << "\n\n";
     }

References blockSize, computeDual, computeWeights, ensureMonotonicity, fCheck, fVolumetric, getMeshTypeName(), moab::TempestRemapper::ICO, intxFilename, kdtreeSearch, meshType, n_procs, nlayers, outFilename, moab::TempestRemapper::OVERLAP_MOAB, skip_intersection, and useGnomonicProjection.

Referenced by ParseCLOptions().

◆ processMeshOptions()

void ToolContext::processMeshOptions ( ProgOptions & opts )

inlineprivate

Process mesh options from command line.

Parameters

opts	Program options
expectedFVMethod	Expected finite volume method
nlayer_input	Number of ghost layers

Definition at line 673 of file mbtempest.cpp.

     {
         if( this->meshType <= moab::TempestRemapper::ICO ) return;
  
         // Process input files
         std::vector< std::string > inputFiles;
         opts.getOptAllArgs( "load,l", inputFiles );
         if( !inputFiles.empty() )
         {
             this->inFilenames = inputFiles;
             if( this->inFilenames.size() != 2 )
             {
                 throw std::runtime_error( "Exactly two input filenames must be provided with -l/--load" );
             }
         }
  
         // Process discretization orders
         std::vector< int > orders;
         opts.getOptAllArgs( "order,o", orders );
         if( !orders.empty() )
         {
             this->disc_orders = orders;
             if( this->disc_orders.size() == 1 )
             {
                 this->disc_orders.push_back( this->disc_orders[0] );
             }
             else if( this->disc_orders.size() != 2 )
             {
                 throw std::runtime_error( "Must specify 1 or 2 values for order (source [target])" );
             }
  
             for( const auto& order : this->disc_orders )
             {
                 if( order < 1 || order > 4 )
                 {
                     throw std::runtime_error( "Discretization order must be between 1 and 4" );
                 }
             }
         }
  
         // Process discretization methods
         std::vector< std::string > methods;
         opts.getOptAllArgs( "method,m", methods );
         if( !methods.empty() )
         {
             this->disc_methods = methods;
             if( this->disc_methods.size() == 1 )
             {
                 // Use same method for both source and target
                 this->disc_methods.push_back( this->disc_methods[0] );
             }
             else if( this->disc_methods.size() != 2 )
             {
                 throw std::runtime_error( "Must specify 1 or 2 values for method (source [target])" );
             }
  
             // Validate method values
             for( const auto& method : this->disc_methods )
             {
                 if( method != "fv" && method != "cgll" && method != "dgll" && method != "pcloud" )
                 {
                     throw std::runtime_error( "Invalid method '" + method + "'. Must be one of: fv, cgll, dgll" );
                 }
             }
         }
  
         // Process DOF tag names
         std::vector< std::string > tags;
         opts.getOptAllArgs( "global_id,i", tags );
         if( !tags.empty() )
         {
             this->doftag_names = tags;
             if( this->doftag_names.size() == 1 )
             {
                 // Use same tag name for both source and target
                 this->doftag_names.push_back( this->doftag_names[0] );
             }
             else if( this->doftag_names.size() != 2 )
             {
                 throw std::runtime_error( "Must specify 1 or 2 values for DOF tag names (source [target])" );
             }
         }
  
         // Process output filename if specified
         std::string outFile;
         if( opts.getOpt( "file,f", &outFile ) )
         {
             this->outFilename = outFile;
         }
         // Note: configureMapOptions is now called from ParseCLOptions after processMeshOptions completes
     }

References ProgOptions::getOpt(), ProgOptions::getOptAllArgs(), moab::TempestRemapper::ICO, meshType, and outFilename.

Referenced by ParseCLOptions().

◆ timer_pop()

void ToolContext::timer_pop ( )

inline

Stop timing and log the operation duration.

Definition at line 215 of file mbtempest.cpp.

     {
         double locElapsed = timer->time_since_birth() - timer_ops;
         double avgElapsed = locElapsed;
         double maxElapsed = locElapsed;
  
 #ifdef MOAB_HAVE_MPI
         MPI_Reduce( &locElapsed, &maxElapsed, 1, MPI_DOUBLE, MPI_MAX, 0, pcomm->comm() );
         MPI_Reduce( &locElapsed, &avgElapsed, 1, MPI_DOUBLE, MPI_SUM, 0, pcomm->comm() );
         avgElapsed /= n_procs;
 #endif
  
         if( proc_id == 0 )
         {
             std::cout << "[LOG] Time taken to " << opName << ": max = " << maxElapsed << ", avg = " << avgElapsed
                       << "\n";
         }
         opName.clear();
     }

References moab::ParallelComm::comm(), n_procs, opName, proc_id, timer, and timer_ops.

Referenced by anonymous_namespace{mbtempest.cpp}::convertAndWriteMOABMesh(), anonymous_namespace{mbtempest.cpp}::handleCSMesh(), anonymous_namespace{mbtempest.cpp}::handleICOMesh(), anonymous_namespace{mbtempest.cpp}::handleOverlapFiles(), anonymous_namespace{mbtempest.cpp}::handleRLLMesh(), and main().

◆ timer_push()

void ToolContext::timer_push ( const std::string & operation )

inline

Start timing an operation.

Parameters

operation Name of the operation being timed

Definition at line 206 of file mbtempest.cpp.

     {
         timer_ops = timer->time_since_birth();
         opName    = operation;
     }

References opName, timer, and timer_ops.

Referenced by anonymous_namespace{mbtempest.cpp}::convertAndWriteMOABMesh(), anonymous_namespace{mbtempest.cpp}::handleCSMesh(), anonymous_namespace{mbtempest.cpp}::handleICOMesh(), anonymous_namespace{mbtempest.cpp}::handleOverlapFiles(), anonymous_namespace{mbtempest.cpp}::handleRLLMesh(), and main().

Member Data Documentation

◆ baselineFile

std::string ToolContext::baselineFile

Baseline file for verification (optional)

Definition at line 115 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ blockSize

int ToolContext::blockSize { 5 }

Block size for vectorized operations.

Definition at line 147 of file mbtempest.cpp.

Referenced by anonymous_namespace{mbtempest.cpp}::handleCSMesh(), anonymous_namespace{mbtempest.cpp}::handleICOMesh(), anonymous_namespace{mbtempest.cpp}::handleRLLMesh(), ParseCLOptions(), and printRuntimeParameters().

◆ boxeps

double ToolContext::boxeps { 1e-7 }

Epsilon for bounding box checks.

Definition at line 131 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ cassType

moab::TempestOnlineMap::CAASType ToolContext::cassType

Initial value:

{

moab::TempestOnlineMap::CAAS_NONE }

Conservative and accurate advection scheme type.

Definition at line 121 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ computeDual

bool ToolContext::computeDual { false }

Compute dual mesh.

Definition at line 136 of file mbtempest.cpp.

Referenced by anonymous_namespace{mbtempest.cpp}::handleICOMesh(), ParseCLOptions(), and printRuntimeParameters().

◆ computeWeights

bool ToolContext::computeWeights { false }

Compute interpolation weights.

Definition at line 137 of file mbtempest.cpp.

Referenced by anonymous_namespace{mbtempest.cpp}::handleOverlapMOAB(), main(), ParseCLOptions(), and printRuntimeParameters().

◆ disc_methods

std::vector< std::string > ToolContext::disc_methods

Discretization methods (fv, cgll, dgll) for source and target.

Definition at line 111 of file mbtempest.cpp.

Referenced by anonymous_namespace{mbtempest.cpp}::handleOverlapMOAB(), main(), and ToolContext().

◆ disc_orders

std::vector< int > ToolContext::disc_orders

Discretization orders for source and target.

Definition at line 110 of file mbtempest.cpp.

Referenced by main(), and ToolContext().

◆ doftag_names

std::vector< std::string > ToolContext::doftag_names

Degree of freedom tag names for source and target.

Definition at line 112 of file mbtempest.cpp.

Referenced by main(), and ToolContext().

◆ enforceConvexity

bool ToolContext::enforceConvexity { false }

Enforce convexity in mesh elements.

Definition at line 140 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ ensureMonotonicity

int ToolContext::ensureMonotonicity { 0 }

Monotonicity enforcement level (0=none, 1=basic, 2=full, 3=strict)

Definition at line 123 of file mbtempest.cpp.

Referenced by configureMapOptions(), main(), ParseCLOptions(), and printRuntimeParameters().

◆ epsrel

double ToolContext::epsrel { ReferenceTolerance }

Relative tolerance for convergence.

Definition at line 132 of file mbtempest.cpp.

Referenced by main().

◆ fCheck

bool ToolContext::fCheck { false }

Enable additional checking during remapping.

Definition at line 126 of file mbtempest.cpp.

Referenced by configureMapOptions(), main(), ParseCLOptions(), and printRuntimeParameters().

◆ fvMethod

std::string ToolContext::fvMethod { "none" }

Finite volume method specification.

Definition at line 117 of file mbtempest.cpp.

Referenced by configureMapOptions(), and ParseCLOptions().

◆ fVolumetric

bool ToolContext::fVolumetric { false }

Enable volumetric (3D) remapping.

Definition at line 127 of file mbtempest.cpp.

Referenced by configureMapOptions(), ParseCLOptions(), and printRuntimeParameters().

◆ inFilenames

std::vector< std::string > ToolContext::inFilenames

Input filenames for source and target meshes.

Definition at line 109 of file mbtempest.cpp.

Referenced by anonymous_namespace{mbtempest.cpp}::handleOverlapFiles(), anonymous_namespace{mbtempest.cpp}::handleOverlapMemory(), anonymous_namespace{mbtempest.cpp}::handleOverlapMOAB(), main(), and ToolContext().

◆ intxFilename

std::string ToolContext::intxFilename

Intersection mesh filename (optional)

Definition at line 114 of file mbtempest.cpp.

Referenced by main(), ParseCLOptions(), and printRuntimeParameters().

◆ kdtreeSearch

bool ToolContext::kdtreeSearch { true }

Enable KD-tree for spatial searches.

Definition at line 125 of file mbtempest.cpp.

Referenced by main(), ParseCLOptions(), and printRuntimeParameters().

◆ mapOptions

GenerateOfflineMapAlgorithmOptions ToolContext::mapOptions

Configuration for offline map generation.

Definition at line 120 of file mbtempest.cpp.

Referenced by main(), ParseCLOptions(), and ToolContext().

◆ mbcore

moab::Core* const ToolContext::mbcore

MOAB Core instance for mesh operations.

Definition at line 99 of file mbtempest.cpp.

Referenced by anonymous_namespace{mbtempest.cpp}::convertAndWriteMOABMesh(), and anonymous_namespace{mbtempest.cpp}::handleOverlapMOAB().

◆ meshes

std::vector< Mesh* > ToolContext::meshes

Collection of TempestRemap meshes.

Definition at line 150 of file mbtempest.cpp.

Referenced by anonymous_namespace{mbtempest.cpp}::handleCSMesh(), anonymous_namespace{mbtempest.cpp}::handleICOMesh(), anonymous_namespace{mbtempest.cpp}::handleOverlapFiles(), anonymous_namespace{mbtempest.cpp}::handleOverlapMemory(), anonymous_namespace{mbtempest.cpp}::handleOverlapMOAB(), anonymous_namespace{mbtempest.cpp}::handleRLLMesh(), and main().

◆ meshsets

std::vector< moab::EntityHandle > ToolContext::meshsets

MOAB entity sets for meshes.

Definition at line 151 of file mbtempest.cpp.

Referenced by anonymous_namespace{mbtempest.cpp}::handleOverlapMemory(), anonymous_namespace{mbtempest.cpp}::handleOverlapMOAB(), and main().

◆ meshType

moab::TempestRemapper::TempestMeshType ToolContext::meshType { moab::TempestRemapper::DEFAULT }

Type of mesh to generate.

Definition at line 108 of file mbtempest.cpp.

Referenced by CreateTempestMesh(), getMeshTypeName(), main(), ParseCLOptions(), printRuntimeParameters(), and processMeshOptions().

◆ n_procs

const int ToolContext::n_procs

Total number of MPI processes (1 for serial)

Definition at line 104 of file mbtempest.cpp.

Referenced by get_file_read_options(), anonymous_namespace{mbtempest.cpp}::handleOverlapMOAB(), printRuntimeParameters(), and timer_pop().

◆ nlayers

int ToolContext::nlayers { 0 }

Number of ghost layers for parallel operations.

Definition at line 146 of file mbtempest.cpp.

Referenced by configureMapOptions(), main(), and printRuntimeParameters().

◆ opName

std::string ToolContext::opName

Name of current operation being timed.

Definition at line 145 of file mbtempest.cpp.

Referenced by timer_pop(), and timer_push().

◆ outFilename

std::string ToolContext::outFilename { "outputFile.nc" }

Output filename for remapping results.

Definition at line 113 of file mbtempest.cpp.

Referenced by configureMapOptions(), anonymous_namespace{mbtempest.cpp}::convertAndWriteMOABMesh(), anonymous_namespace{mbtempest.cpp}::handleCSMesh(), anonymous_namespace{mbtempest.cpp}::handleICOMesh(), anonymous_namespace{mbtempest.cpp}::handleOverlapFiles(), anonymous_namespace{mbtempest.cpp}::handleRLLMesh(), main(), ParseCLOptions(), printRuntimeParameters(), and processMeshOptions().

◆ outputFormatter

moab::DebugOutput ToolContext::outputFormatter

Formatter for debug output.

Definition at line 105 of file mbtempest.cpp.

Referenced by anonymous_namespace{mbtempest.cpp}::convertAndWriteMOABMesh(), CreateTempestMesh(), main(), and ToolContext().

◆ print_diagnostics

bool ToolContext::print_diagnostics { false }

Print detailed diagnostic information.

Definition at line 129 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ proc_id

const int ToolContext::proc_id

MPI process rank (0 for serial)

Definition at line 103 of file mbtempest.cpp.

Referenced by anonymous_namespace{mbtempest.cpp}::convertAndWriteMOABMesh(), CreateTempestMesh(), get_file_read_options(), anonymous_namespace{mbtempest.cpp}::handleOverlapMOAB(), main(), ParseCLOptions(), and timer_pop().

◆ rrmGrids

bool ToolContext::rrmGrids { false }

Flag to use RRM (Regional Refinement Meshes)

Definition at line 124 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ skip_intersection

bool ToolContext::skip_intersection { false }

Skip intersection computation (for debugging)

Definition at line 130 of file mbtempest.cpp.

Referenced by configureMapOptions(), main(), ParseCLOptions(), and printRuntimeParameters().

◆ skip_io

bool ToolContext::skip_io { false }

Skip file I/O operations (for testing)

Definition at line 135 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ timer

std::unique_ptr< moab::CpuTimer > ToolContext::timer

Timer for performance measurement.

Definition at line 143 of file mbtempest.cpp.

Referenced by timer_pop(), timer_push(), and ToolContext().

◆ timer_ops

double ToolContext::timer_ops { 0.0 }

Operation timer value.

Definition at line 144 of file mbtempest.cpp.

Referenced by timer_pop(), and timer_push().

◆ useGnomonicProjection

bool ToolContext::useGnomonicProjection { false }

Use gnomonic projection for certain operations.

Definition at line 128 of file mbtempest.cpp.

Referenced by main(), ParseCLOptions(), and printRuntimeParameters().

◆ variableToVerify

std::string ToolContext::variableToVerify

Variable name for verification (optional)

Definition at line 116 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ verifyConservation

bool ToolContext::verifyConservation { false }

Verify conservation properties.

Definition at line 138 of file mbtempest.cpp.

◆ verifyWeights

bool ToolContext::verifyWeights { false }

Verify interpolation weights.

Definition at line 139 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

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

mbtempest.cpp

Public Member Functions

Public Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ ToolContext() [1/3]

◆ ~ToolContext()

◆ ToolContext() [2/3]

◆ ToolContext() [3/3]

Member Function Documentation

◆ configureMapOptions()

◆ get_file_read_options()

◆ getMeshTypeName()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ ParseCLOptions()

◆ printHelp()

◆ printRuntimeParameters()

◆ processMeshOptions()

◆ timer_pop()

◆ timer_push()

Member Data Documentation

◆ baselineFile

◆ blockSize

◆ boxeps

◆ cassType

◆ computeDual

◆ computeWeights

◆ disc_methods

◆ disc_orders

◆ doftag_names

◆ enforceConvexity

◆ ensureMonotonicity

◆ epsrel

◆ fCheck

◆ fvMethod

◆ fVolumetric

◆ inFilenames

◆ intxFilename

◆ kdtreeSearch

◆ mapOptions

◆ mbcore

◆ meshes

◆ meshsets

◆ meshType

◆ n_procs

◆ nlayers

◆ opName

◆ outFilename

◆ outputFormatter

◆ print_diagnostics

◆ proc_id

◆ rrmGrids

◆ skip_intersection

◆ skip_io

◆ timer

◆ timer_ops

◆ useGnomonicProjection

◆ variableToVerify

◆ verifyConservation

◆ verifyWeights