Collaboration diagram for ToolContext:

Public Member Functions
	ToolContext (moab::Core *icore)

	~ToolContext ()

void	timer_push (std::string operation)

void	timer_pop ()

void	ParseCLOptions (int argc, char *argv[])

Public Attributes
moab::Core *	mbcore

const int	proc_id

const int	n_procs

moab::DebugOutput	outputFormatter

int	blockSize

int	nlayers

std::vector< std::string >	inFilenames

std::vector< Mesh * >	meshes

std::vector< moab::EntityHandle >	meshsets

std::vector< int >	disc_orders

std::vector< std::string >	disc_methods

std::vector< std::string >	doftag_names

std::string	fvMethod

std::string	outFilename

std::string	intxFilename

std::string	baselineFile

std::string	variableToVerify

moab::TempestRemapper::TempestMeshType	meshType

bool	skip_io

bool	computeDual

bool	computeWeights

bool	verifyWeights

bool	enforceConvexity

int	ensureMonotonicity

bool	rrmGrids

bool	kdtreeSearch

bool	fCheck

bool	fVolumetric

bool	useGnomonicProjection

moab::TempestOnlineMap::CAASType	cassType

GenerateOfflineMapAlgorithmOptions	mapOptions

bool	print_diagnostics

double	boxeps

double	epsrel

Private Attributes
moab::CpuTimer *	timer

double	timer_ops

std::string	opName

Detailed Description

Definition at line 44 of file mbtempest.cpp.

Constructor & Destructor Documentation

◆ ToolContext()

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

inline

Definition at line 89 of file mbtempest.cpp.

         : mbcore( icore ), proc_id( 0 ), n_procs( 1 ), outputFormatter( std::cout, 0, 0 ),
 #endif
           blockSize( 5 ), nlayers( 0 ), fvMethod( "none" ), outFilename( "outputFile.nc" ), intxFilename( "" ),
           baselineFile( "" ), variableToVerify( "" ), meshType( moab::TempestRemapper::DEFAULT ), skip_io( false ),
           computeDual( false ), computeWeights( false ), verifyWeights( false ), enforceConvexity( false ),
           ensureMonotonicity( 0 ), rrmGrids( false ), kdtreeSearch( true ), fCheck( false ), fVolumetric( false ),
           useGnomonicProjection( false ), cassType( moab::TempestOnlineMap::CAAS_NONE ), print_diagnostics( false ),
           boxeps( 1e-7 ),               // Box error tolerance default value
           epsrel( ReferenceTolerance )  // ReferenceTolerance is defined in Defines.h in TempestRemap
     {
         inFilenames.resize( 2 );
         doftag_names.resize( 2 );
         timer = new moab::CpuTimer();
  
         outputFormatter.set_prefix( "[MBTempest]: " );
     }

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

◆ ~ToolContext()

ToolContext::~ToolContext ( )

inline

Definition at line 107 of file mbtempest.cpp.

     {
         // for (unsigned i=0; i < meshes.size(); ++i) delete meshes[i];
         meshes.clear();
         inFilenames.clear();
         disc_orders.clear();
         disc_methods.clear();
         doftag_names.clear();
         outFilename.clear();
         intxFilename.clear();
         baselineFile.clear();
         variableToVerify.clear();
         meshsets.clear();
         delete timer;
     }

References baselineFile, disc_methods, disc_orders, doftag_names, inFilenames, intxFilename, meshes, meshsets, outFilename, timer, and variableToVerify.

Member Function Documentation

◆ ParseCLOptions()

void ToolContext::ParseCLOptions	(	int	argc,
		char *	argv[]
	)

inline

Definition at line 150 of file mbtempest.cpp.

     {
         ProgOptions opts;
         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               = 0;
  
         if( !proc_id )
         {
             std::cout << "Command line options provided to mbtempest:\n  ";
             for( int iarg = 0; iarg < argc; ++iarg )
                 std::cout << argv[iarg] << " ";
             std::cout << std::endl << std::endl;
         }
  
         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 );
         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. (relevant only when computing weights)" );
  
         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 );
  
         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 );
  
         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_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 (default=1)", &nlayer_input );
  
         opts.addOpt< double >( "boxeps", "The tolerance for boxes (default=1e-7)", &boxeps );
  
         opts.addOpt< int >( "caas", "apply CAAS nonlinear filter after linear map application", &useCAAS );
  
         opts.addOpt< std::string >( "baseline", "Output baseline file", &baselineFile );
  
         opts.parseCommandLine( argc, argv );
  
         // By default - use Kd-tree based search; if user asks for advancing front, disable Kd-tree
         // algorithm
         kdtreeSearch = opts.numOptSet( "advfront,a" ) == 0;
  
         switch( imeshType )
         {
             case 0:
                 meshType = moab::TempestRemapper::CS;
                 break;
  
             case 1:
                 meshType = moab::TempestRemapper::RLL;
                 break;
  
             case 2:
                 meshType = moab::TempestRemapper::ICO;
                 break;
  
             case 3:
                 meshType = moab::TempestRemapper::OVERLAP_FILES;
                 break;
  
             case 4:
                 meshType = moab::TempestRemapper::OVERLAP_MEMORY;
                 break;
  
             case 5:
                 meshType = moab::TempestRemapper::OVERLAP_MOAB;
                 break;
  
             default:
                 meshType = moab::TempestRemapper::DEFAULT;
                 break;
         }
  
         // decipher whether we want to use CAAS filter when applying the projection
         switch( useCAAS )
         {
             case moab::TempestOnlineMap::CAAS_GLOBAL:
                 cassType = moab::TempestOnlineMap::CAAS_GLOBAL;
                 break;
             case moab::TempestOnlineMap::CAAS_LOCAL:
                 cassType = moab::TempestOnlineMap::CAAS_LOCAL;
                 break;
             case moab::TempestOnlineMap::CAAS_LOCAL_ADJACENT:
                 cassType = moab::TempestOnlineMap::CAAS_LOCAL_ADJACENT;
                 break;
             case moab::TempestOnlineMap::CAAS_QLT:
                 cassType = moab::TempestOnlineMap::CAAS_QLT;
                 break;
             default:
                 cassType = moab::TempestOnlineMap::CAAS_NONE;
                 break;
         }
  
         if( meshType > moab::TempestRemapper::ICO )  // compute overlap mesh and maps possibly
         {
             opts.getOptAllArgs( "load,l", inFilenames );
             opts.getOptAllArgs( "order,o", disc_orders );
             opts.getOptAllArgs( "method,m", disc_methods );
             opts.getOptAllArgs( "global_id,i", doftag_names );
  
             assert( inFilenames.size() == 2 );
             assert( ensureMonotonicity >= 0 && ensureMonotonicity <= 3 );
  
             // get discretization order parameters
             if( disc_orders.size() == 0 ) disc_orders.resize( 2, 1 );
             if( disc_orders.size() == 1 ) disc_orders.push_back( disc_orders[0] );
  
             // get discretization method parameters
             if( disc_methods.size() == 0 ) disc_methods.resize( 2, "fv" );
             if( disc_methods.size() == 1 ) disc_methods.push_back( disc_methods[0] );
  
             // get DoF tagname parameters
             if( doftag_names.size() == 0 ) doftag_names.resize( 2, "GLOBAL_ID" );
             if( doftag_names.size() == 1 ) doftag_names.push_back( doftag_names[0] );
  
             assert( disc_orders.size() == 2 );
             assert( disc_methods.size() == 2 );
             assert( doftag_names.size() == 2 );
  
             // for computing maps and overlaps, set discretization orders
             mapOptions.nPin           = disc_orders[0];
             mapOptions.nPout          = disc_orders[1];
             mapOptions.fSourceConcave = false;
             mapOptions.fTargetConcave = false;
  
             mapOptions.strMethod = "";
  
             if( expectedFVMethod != "none" )
             {
                 mapOptions.strMethod += expectedFVMethod + ";";
                 fvMethod = expectedFVMethod;
  
                 // These FV projection methods are non-conservative; specify it explicitly
                 mapOptions.fNoConservation = true;
             }
             switch( ensureMonotonicity )
             {
                 case 0:
                     mapOptions.fMonotone = false;
                     break;
                 case 3:
                     mapOptions.strMethod += "mono3;";
                     break;
                 case 2:
                     mapOptions.strMethod += "mono2;";
                     break;
                 default:
                     mapOptions.fMonotone = true;
             }
             mapOptions.fNoCorrectAreas = false;
             mapOptions.fNoCheck        = !fCheck;
  
             //assert( fVolumetric && fInverseDistanceMap == false );  // both options cannot be active
             if( fVolumetric ) mapOptions.strMethod += "volumetric;";
  
             // For global meshes, this default should work out of the box.
             if( !fvMethod.compare( "bilin" ) ) nlayers = 3;
             else
                 nlayers = ( mapOptions.nPin > 1 ? mapOptions.nPin + 1 : 0 );
             if ( nlayer_input )
               nlayers = std::max( nlayer_input, nlayers );
         }
  
         // clear temporary string name
         expectedFName.clear();
  
         mapOptions.strOutputMapFile = outFilename;
         mapOptions.strOutputFormat  = "Netcdf4";
     }

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, moab::TempestRemapper::CS, moab::TempestRemapper::DEFAULT, disc_methods, disc_orders, doftag_names, enforceConvexity, ensureMonotonicity, fCheck, fvMethod, fVolumetric, ProgOptions::getOptAllArgs(), moab::TempestRemapper::ICO, inFilenames, intxFilename, kdtreeSearch, mapOptions, meshType, nlayers, ProgOptions::numOptSet(), outFilename, moab::TempestRemapper::OVERLAP_FILES, moab::TempestRemapper::OVERLAP_MEMORY, moab::TempestRemapper::OVERLAP_MOAB, ProgOptions::parseCommandLine(), print_diagnostics, proc_id, moab::TempestRemapper::RLL, rrmGrids, skip_io, useGnomonicProjection, variableToVerify, and verifyWeights.

Referenced by main().

◆ timer_pop()

void ToolContext::timer_pop ( )

inline

Definition at line 129 of file mbtempest.cpp.

     {
         double locElapsed = timer->time_since_birth() - timer_ops, avgElapsed = 0, maxElapsed = 0;
 #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() );
 #else
         maxElapsed = locElapsed;
         avgElapsed = locElapsed;
 #endif
         if( !proc_id )
         {
             avgElapsed /= n_procs;
             std::cout << "[LOG] Time taken to " << opName.c_str() << ": max = " << maxElapsed
                       << ", avg = " << avgElapsed << "\n";
         }
         // std::cout << "\n[LOG" << proc_id << "] Time taken to " << opName << " = " <<
         // timer->time_since_birth() - timer_ops << std::endl;
         opName.clear();
     }

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

Referenced by CreateTempestMesh(), and main().

◆ timer_push()

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

inline

Definition at line 123 of file mbtempest.cpp.

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

References opName, moab::CpuTimer::time_since_birth(), timer, and timer_ops.

Referenced by CreateTempestMesh(), and main().

Member Data Documentation

◆ baselineFile

std::string ToolContext::baselineFile

Definition at line 63 of file mbtempest.cpp.

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

◆ blockSize

int ToolContext::blockSize

Definition at line 52 of file mbtempest.cpp.

Referenced by CreateTempestMesh(), and ParseCLOptions().

◆ boxeps

double ToolContext::boxeps

Definition at line 81 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ cassType

moab::TempestOnlineMap::CAASType ToolContext::cassType

Definition at line 78 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ computeDual

bool ToolContext::computeDual

Definition at line 68 of file mbtempest.cpp.

Referenced by CreateTempestMesh(), and ParseCLOptions().

◆ computeWeights

bool ToolContext::computeWeights

Definition at line 69 of file mbtempest.cpp.

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

◆ disc_methods

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

Definition at line 58 of file mbtempest.cpp.

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

◆ disc_orders

std::vector< int > ToolContext::disc_orders

Definition at line 57 of file mbtempest.cpp.

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

◆ doftag_names

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

Definition at line 59 of file mbtempest.cpp.

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

◆ enforceConvexity

bool ToolContext::enforceConvexity

Definition at line 71 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ ensureMonotonicity

int ToolContext::ensureMonotonicity

Definition at line 72 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ epsrel

double ToolContext::epsrel

Definition at line 82 of file mbtempest.cpp.

Referenced by main().

◆ fCheck

bool ToolContext::fCheck

Definition at line 75 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ fvMethod

std::string ToolContext::fvMethod

Definition at line 60 of file mbtempest.cpp.

Referenced by ParseCLOptions().

◆ fVolumetric

bool ToolContext::fVolumetric

Definition at line 76 of file mbtempest.cpp.

Referenced by ParseCLOptions().

◆ inFilenames

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

Definition at line 54 of file mbtempest.cpp.

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

◆ intxFilename

std::string ToolContext::intxFilename

Definition at line 62 of file mbtempest.cpp.

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

◆ kdtreeSearch

bool ToolContext::kdtreeSearch

Definition at line 74 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ mapOptions

GenerateOfflineMapAlgorithmOptions ToolContext::mapOptions

Definition at line 79 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ mbcore

moab::Core* ToolContext::mbcore

Definition at line 46 of file mbtempest.cpp.

Referenced by CreateTempestMesh(), and main().

◆ meshes

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

Definition at line 55 of file mbtempest.cpp.

Referenced by CreateTempestMesh(), main(), and ~ToolContext().

◆ meshsets

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

Definition at line 56 of file mbtempest.cpp.

Referenced by CreateTempestMesh(), main(), and ~ToolContext().

◆ meshType

moab::TempestRemapper::TempestMeshType ToolContext::meshType

Definition at line 66 of file mbtempest.cpp.

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

◆ n_procs

const int ToolContext::n_procs

Definition at line 50 of file mbtempest.cpp.

Referenced by CreateTempestMesh(), get_file_read_options(), and timer_pop().

◆ nlayers

int ToolContext::nlayers

Definition at line 53 of file mbtempest.cpp.

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

◆ opName

std::string ToolContext::opName

private

Definition at line 407 of file mbtempest.cpp.

Referenced by timer_pop(), and timer_push().

◆ outFilename

std::string ToolContext::outFilename

Definition at line 61 of file mbtempest.cpp.

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

◆ outputFormatter

moab::DebugOutput ToolContext::outputFormatter

Definition at line 51 of file mbtempest.cpp.

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

◆ print_diagnostics

bool ToolContext::print_diagnostics

Definition at line 80 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ proc_id

const int ToolContext::proc_id

Definition at line 50 of file mbtempest.cpp.

Referenced by CreateTempestMesh(), get_file_read_options(), main(), ParseCLOptions(), and timer_pop().

◆ rrmGrids

bool ToolContext::rrmGrids

Definition at line 73 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ skip_io

bool ToolContext::skip_io

Definition at line 67 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ timer

moab::CpuTimer* ToolContext::timer

private

Definition at line 405 of file mbtempest.cpp.

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

◆ timer_ops

double ToolContext::timer_ops

private

Definition at line 406 of file mbtempest.cpp.

Referenced by timer_pop(), and timer_push().

◆ useGnomonicProjection

bool ToolContext::useGnomonicProjection

Definition at line 77 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

◆ variableToVerify

std::string ToolContext::variableToVerify

Definition at line 64 of file mbtempest.cpp.

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

◆ verifyWeights

bool ToolContext::verifyWeights

Definition at line 70 of file mbtempest.cpp.

Referenced by main(), and ParseCLOptions().

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

mbtempest.cpp

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ToolContext()

◆ ~ToolContext()

Member Function Documentation

◆ ParseCLOptions()

◆ 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_io

◆ timer

◆ timer_ops

◆ useGnomonicProjection

◆ variableToVerify

◆ verifyWeights