moab::TempestRemapper Class Reference

#include <TempestRemapper.hpp>

Inheritance diagram for moab::TempestRemapper:

Collaboration diagram for moab::TempestRemapper:

Public Types
enum	TempestMeshType {   DEFAULT = -1 , CS = 0 , RLL = 1 , ICO = 2 ,   ICOD = 3 , OVERLAP_FILES = 4 , OVERLAP_MEMORY = 5 , OVERLAP_MOAB = 6 }
Public Types inherited from moab::Remapper
enum	IntersectionContext {   DEFAULT = -1 , SourceMesh = 0 , TargetMesh = 1 , OverlapMesh = 2 ,   CoveringMesh = 3 }

Public Member Functions
	TempestRemapper (moab::Interface *mbInt, bool offlineMode=false)
virtual	~TempestRemapper ()
virtual ErrorCode	initialize (bool initialize_fsets=true)
	Initialize the TempestRemapper object internal data structures including the mesh sets and TempestRemap mesh references. More...
virtual ErrorCode	clear ()
	Deallocate and clear any memory initialized in the TempestRemapper object. More...
moab::ErrorCode	GenerateMesh (Remapper::IntersectionContext ctx, TempestMeshType type)
	Generate a mesh in memory of given type (CS/RLL/ICO/MPAS(structured)) and store it under the context specified by the user. More...
moab::ErrorCode	ConstructCoveringSet (double tolerance=1e-8, double radius_src=1.0, double radius_tgt=1.0, double boxeps=0.1, bool regional_mesh=false, bool gnomonic=true, int nb_ghost_layers=0)
	Construct a source covering mesh such that it completely encompasses the target grid in parallel. This operation is critical to ensure that the parallel advancing-front intersection algorithm can compute the intersection mesh only locally without any process communication. More...
void	SetAreaMethod (IntxAreaUtils::AreaMethod method)
	Validate the GLOBAL_ID tags on the source and target meshes. More...
IntxAreaUtils::AreaMethod	GetAreaMethod () const
	Formula currently used for spherical area computations. More...
void	SetRegionalMesh (bool regional)
	Declare that the source and/or target mesh is regionally refined, so their domains need not coincide. More...
bool	IsRegionalMesh () const
	Whether the meshes have been declared regionally refined; see SetRegionalMesh(). More...
moab::ErrorCode	ValidateGlobalIds (bool throw_error=true)
moab::ErrorCode	ComputeOverlapMesh (bool kdtree_search=true, bool use_tempest=false)
	Compute the intersection mesh between the source and target grids that have been instantiated in the Remapper. This function invokes the parallel advancing-front intersection algorithm internally for spherical meshes and can handle arbitrary unstructured grids (CS, RLL, ICO, MPAS) with and without holes. More...
moab::ErrorCode	ConvertTempestMesh (Remapper::IntersectionContext ctx)
	Convert the TempestRemap mesh object to a corresponding MOAB mesh representation according to the intersection context. More...
moab::ErrorCode	ConvertMeshToTempest (Remapper::IntersectionContext ctx)
	Convert the MOAB mesh representation to a corresponding TempestRemap mesh object according to the intersection context. More...
Mesh *	GetMesh (Remapper::IntersectionContext ctx)
	Get the TempestRemap mesh object according to the intersection context. More...
void	SetMesh (Remapper::IntersectionContext ctx, Mesh *mesh, bool overwrite=true)
	Set the TempestRemap mesh object according to the intersection context. More...
void	SetMeshSet (Remapper::IntersectionContext ctx, moab::EntityHandle mset, moab::Range *entities=nullptr)
	Set the mesh set according to the intersection context. More...
Mesh *	GetCoveringMesh ()
	Get the covering mesh (TempestRemap) object. More...
moab::EntityHandle &	GetMeshSet (Remapper::IntersectionContext ctx)
	Get the MOAB mesh set corresponding to the intersection context. More...
moab::EntityHandle	GetMeshSet (Remapper::IntersectionContext ctx) const
	Const overload. Get the MOAB mesh set corresponding to the intersection context. More...
moab::Range &	GetMeshEntities (Remapper::IntersectionContext ctx)
	Get the mesh element entities corresponding to the intersection context. More...
const moab::Range &	GetMeshEntities (Remapper::IntersectionContext ctx) const
	Const overload. Get the mesh element entities corresponding to the intersection context. More...
moab::Range &	GetMeshVertices (Remapper::IntersectionContext ctx)
	Get the mesh vertices corresponding to the intersection context. Useful for point-cloud meshes. More...
const moab::Range &	GetMeshVertices (Remapper::IntersectionContext ctx) const
	Const overload. Get the mesh vertices corresponding to the intersection context. Useful for point-cloud meshes. More...
moab::EntityHandle &	GetCoveringSet ()
	Get access to the underlying source covering set if available. Else return the source set. More...
void	SetMeshType (Remapper::IntersectionContext ctx, const std::vector< int > &metadata)
	Set the mesh type corresponding to the intersection context. More...
void	ResetMeshSet (Remapper::IntersectionContext ctx, moab::EntityHandle meshSet)
	Reconstruct mesh, used now only for IO; need a better solution maybe. More...
TempestMeshType	GetMeshType (Remapper::IntersectionContext ctx) const
	Get the mesh type corresponding to the intersection context. More...
moab::ErrorCode	WriteTempestIntersectionMesh (std::string strOutputFileName, const bool fAllParallel, const bool fInputConcave, const bool fOutputConcave)
	Gather the overlap mesh and associated source/target data and write it out to disk using the TempestRemap output interface. This information can then be used with the "GenerateOfflineMap" tool in TempestRemap as needed. More...
moab::ErrorCode	GenerateCSMeshMetadata (const int ntot_elements, moab::Range &entities, moab::Range *secondary_entities, const std::string &dofTagName, int nP)
	Generate the necessary metadata and specifically the GLL node numbering for DoFs for a CS mesh. This negates the need for running external code like HOMME to output the numbering needed for computing maps. The functionality is used through the mbconvert tool to compute processor-invariant Global DoF IDs at GLL nodes. More...
moab::ErrorCode	GenerateMeshMetadata (Mesh &mesh, const int ntot_elements, moab::Range &entities, moab::Range *secondary_entities, const std::string &dofTagName, int nP)
	Generate the necessary metadata for DoF node numbering in a given mesh. Currently, only the functionality to generate numbering on CS grids is supported. More...
moab::ErrorCode	GetOverlapAugmentedEntities (moab::Range &sharedGhostEntities)
	Get all the ghosted overlap entities that were accumulated to enable conservation in parallel. More...
moab::ErrorCode	assign_vertex_element_IDs (Tag idtag, EntityHandle this_set, const int dimension=2, const int start_id=1)
	Internal method to assign vertex and element global IDs if one does not exist already. More...
ErrorCode	GetIMasks (Remapper::IntersectionContext ctx, std::vector< int > &masks)
	Get the masks that could have been defined. More...
Public Member Functions inherited from moab::Remapper
	Remapper (moab::Interface *mbInt)
virtual	~Remapper ()
moab::Interface *	get_interface ()
ErrorCode	LoadNativeMesh (std::string filename, moab::EntityHandle &meshset, std::vector< int > &metadata, const char *readopts=0)

Public Attributes
const bool	offlineWorkflow
	Flag indicating whether the workflow is in offline mode. More...
bool	meshValidate
	Flag to enable mesh validation after loading from file. More...
bool	constructEdgeMap
	Flag to construct the edge map within the TempestRemap data structures. More...

Static Public Attributes
static const bool	verbose = true
	Global verbosity flag. More...

Private Member Functions
moab::ErrorCode	validate_global_ids_private (moab::EntityHandle mesh_set, int dimension, const char *mesh_name, std::string &error_message)
	Helper for ValidateGlobalIds: check one mesh set at one dimension. More...
ErrorCode	ConvertAllMeshesToTempest ()
	Convert all MOAB meshes to TempestRemap format. More...
moab::ErrorCode	ConvertOverlapMeshSourceOrdered ()
	Convert overlap mesh to source-ordered format. More...
moab::ErrorCode	convert_mesh_to_tempest_private (Mesh *mesh, moab::EntityHandle meshset, moab::Range &entities, moab::Range *pverts)
	Convert a MOAB mesh to TempestRemap format. More...
moab::ErrorCode	convert_tempest_mesh_private (TempestMeshType type, Mesh *mesh, moab::EntityHandle &meshset, moab::Range &entities, moab::Range *vertices)
	Convert a TempestRemap mesh to MOAB format. More...
moab::ErrorCode	AugmentOverlapSet ()
	Augment overlap mesh with ghosted entities. More...

Private Attributes
Mesh *	m_source = nullptr
TempestMeshType	m_source_type
moab::Range	m_source_entities
moab::Range	m_source_vertices
moab::EntityHandle	m_source_set = 0
int	max_source_edges = 0
bool	point_cloud_source = false
std::vector< int >	m_source_metadata
Mesh *	m_target = nullptr
TempestMeshType	m_target_type
moab::Range	m_target_entities
moab::Range	m_target_vertices
moab::EntityHandle	m_target_set = 0
int	max_target_edges = 0
bool	point_cloud_target = false
std::vector< int >	m_target_metadata
Mesh *	m_overlap = nullptr
TempestMeshType	m_overlap_type = DEFAULT
moab::Range	m_overlap_entities
moab::EntityHandle	m_overlap_set = 0
std::vector< std::pair< int, int > >	m_sorted_overlap_order
moab::Intx2MeshOnSphere *	mbintx = nullptr
Mesh *	m_covering_source = nullptr
moab::EntityHandle	m_covering_source_set = 0
moab::Range	m_covering_source_entities
moab::Range	m_covering_source_vertices
IntxAreaUtils::AreaMethod	m_area_method = IntxAreaUtils::DEFAULT_AREA_METHOD
bool	rrmgrids = false
bool	is_parallel = false
bool	is_root = false
int	rank = 0
int	size = 0

Friends
class	TempestOnlineMap

Additional Inherited Members
Protected Attributes inherited from moab::Remapper
Interface *	m_interface

Detailed Description

Definition at line 43 of file TempestRemapper.hpp.

Member Enumeration Documentation

TempestMeshType

enum moab::TempestRemapper::TempestMeshType

Enumerator
DEFAULT
CS
RLL
ICO
ICOD
OVERLAP_FILES
OVERLAP_MEMORY
OVERLAP_MOAB

Definition at line 64 of file TempestRemapper.hpp.

    {
        DEFAULT        = -1,
        CS             = 0,
        RLL            = 1,
        ICO            = 2,
        ICOD           = 3,
        OVERLAP_FILES  = 4,
        OVERLAP_MEMORY = 5,
        OVERLAP_MOAB   = 6
    };

Constructor & Destructor Documentation

TempestRemapper()

moab::TempestRemapper::TempestRemapper ( moab::Interface *  mbInt, bool  offlineMode = false  )

inline

Definition at line 50 of file TempestRemapper.hpp.

        : Remapper( mbInt ),
#endif
          offlineWorkflow( offlineMode ), meshValidate( false ), constructEdgeMap( false ), m_source_type( DEFAULT ),
          m_target_type( DEFAULT )
    {
#ifdef MOAB_HAVE_MPI
        AnnounceOnlyOutputOnRankZero();
#endif
    }

~TempestRemapper()

moab::TempestRemapper::~TempestRemapper ( )

virtual

Definition at line 101 of file TempestRemapper.cpp.

{
    this->clear();
}

References clear().

Member Function Documentation

assign_vertex_element_IDs()

ErrorCode moab::TempestRemapper::assign_vertex_element_IDs	(	Tag	idtag,
		EntityHandle	this_set,
		const int	dimension = 2,
		const int	start_id = 1
	)

Internal method to assign vertex and element global IDs if one does not exist already.

Parameters

idtag	Tag for the global IDs
this_set	MOAB entity handle of the mesh set
dimension	Dimension of the mesh (default: 2)
start_id	Starting ID (default: 1)

Returns

ErrorCode indicating the status of the assignment

Definition at line 1038 of file TempestRemapper.cpp.

{
    assert( idtag );
 
    ErrorCode rval;
    Range entities;
    MB_CHK_SET_ERR( m_interface->get_entities_by_dimension( this_set, dimension, entities ), "Failed to get entities" );
 
    if( entities.size() == 0 ) return moab::MB_SUCCESS;
 
    int idoffset = start_id;
    std::vector< int > gid( entities.size() );
    for( unsigned i = 0; i < entities.size(); ++i )
        gid[i] = idoffset++;
 
    MB_CHK_ERR( m_interface->tag_set_data( idtag, entities, &gid[0] ) );
 
    return moab::MB_SUCCESS;
}

References ErrorCode, moab::Interface::get_entities_by_dimension(), moab::Remapper::m_interface, MB_CHK_ERR, MB_CHK_SET_ERR, MB_SUCCESS, moab::Range::size(), and moab::Interface::tag_set_data().

Referenced by main().

AugmentOverlapSet()

moab::ErrorCode moab::TempestRemapper::AugmentOverlapSet ( )

private

Augment overlap mesh with ghosted entities.

Adds ghosted entities to the overlap mesh to ensure conservation in parallel operations.

Returns

moab::ErrorCode Status of the augmentation

Referenced by ComputeOverlapMesh().

clear()

ErrorCode moab::TempestRemapper::clear ( )

virtual

Deallocate and clear any memory initialized in the TempestRemapper object.

Returns

ErrorCode indicating the status of the clear operation

Definition at line 106 of file TempestRemapper.cpp.

{
    // destroy all meshes
    if( m_source )
    {
        delete m_source;
        m_source = nullptr;
    }
    if( m_target )
    {
        delete m_target;
        m_target = nullptr;
    }
    if( m_overlap )
    {
        delete m_overlap;
        m_overlap = nullptr;
    }
    if( m_covering_source && size > 1 )
    {
        delete m_covering_source;
        m_covering_source = nullptr;
    }
 
    point_cloud_source = false;
    point_cloud_target = false;
 
    m_source_entities.clear();
    m_source_vertices.clear();
    m_covering_source_entities.clear();
    m_covering_source_vertices.clear();
    m_target_entities.clear();
    m_target_vertices.clear();
    m_overlap_entities.clear();
 
    return MB_SUCCESS;
}

References moab::Range::clear(), m_covering_source, m_covering_source_entities, m_covering_source_vertices, m_overlap, m_overlap_entities, m_source, m_source_entities, m_source_vertices, m_target, m_target_entities, m_target_vertices, MB_SUCCESS, point_cloud_source, point_cloud_target, and size.

Referenced by main(), and ~TempestRemapper().

ComputeOverlapMesh()

ErrorCode moab::TempestRemapper::ComputeOverlapMesh	(	bool	kdtree_search = true,
		bool	use_tempest = false
	)

Compute the intersection mesh between the source and target grids that have been instantiated in the Remapper. This function invokes the parallel advancing-front intersection algorithm internally for spherical meshes and can handle arbitrary unstructured grids (CS, RLL, ICO, MPAS) with and without holes.

Parameters

kdtree_search	Flag to enable k-d tree search (default: true)
use_tempest	Flag to use TempestRemap (default: false)

Returns

ErrorCode indicating the status of the intersection mesh computation

Definition at line 1445 of file TempestRemapper.cpp.

{
    const bool outputEnabled = ( this->rank == 0 );
    moab::DebugOutput dbgprint( std::cout, this->rank, 0 );
    dbgprint.set_prefix( "[ComputeOverlapMesh]: " );
 
    //
    // Create the intersection on the sphere object and set up necessary parameters
    //
    // First, split based on whether to use TempestRemap or MOAB for intersection
    // If TempestRemap,
    //   1) Check for valid Mesh and pointers to objects for source/target
    //   2) Invoke GenerateOverlapWithMeshes routine from Tempest library
    // If MOAB,
    //   1) Check for valid source and target meshsets (and entities)
    //   2) Build processor bounding boxes and construct a covering set
    //   3) Perform intersection between the source (covering) and target entities
    if( use_tempest )
    {
        // Now let us construct the overlap mesh, by calling TempestRemap interface directly
        // For the overlap method, choose between: "fuzzy", "exact" or "mixed"
        assert( m_covering_source != nullptr );
        assert( m_target != nullptr );
        if( m_overlap != nullptr ) delete m_overlap;
        bool concaveMeshA = false, concaveMeshB = false;
        // we have reset the overlap mesh - allocate now
        m_overlap = new Mesh();
        // Generate the overlap mesh using TempestRemap
        if( GenerateOverlapWithMeshes( *m_covering_source, *m_target, *m_overlap, "" /*outFilename*/, "Netcdf4",
                                       "exact", concaveMeshA, concaveMeshB, true, false ) )
            MB_CHK_SET_ERR( MB_FAILURE, "TempestRemap: cannot compute the intersection of meshes on the sphere" );
    }
    else
    {
        // Now perform the actual parallel intersection between the source and the target meshes
        if( kdtree_search )
        {
            if( outputEnabled ) dbgprint.printf( 0, "Computing intersection mesh with the Kd-tree search algorithm" );
            MB_CHK_SET_ERR( mbintx->intersect_meshes_kdtree( m_covering_source_set, m_target_set, m_overlap_set ),
                            "Can't compute the intersection of meshes on the sphere with kd-tree" );
        }
        else
        {
            if( outputEnabled )
                dbgprint.printf( 0, "Computing intersection mesh with the advancing-front propagation algorithm" );
            MB_CHK_SET_ERR( mbintx->intersect_meshes( m_covering_source_set, m_target_set, m_overlap_set ),
                            "Can't compute the intersection of meshes on the sphere" );
        }
 
#ifdef MOAB_HAVE_MPI
        if( is_parallel )
        {
#ifdef VERBOSE
            std::stringstream ffc, fft, ffo;
            ffc << "cover_" << rank << ".h5m";
            fft << "target_" << rank << ".h5m";
            ffo << "intx_" << rank << ".h5m";
            MB_CHK_ERR( m_interface->write_mesh( ffc.str().c_str(), &m_covering_source_set, 1 ) );
            MB_CHK_ERR( m_interface->write_mesh( fft.str().c_str(), &m_target_set, 1 ) );
            MB_CHK_ERR( m_interface->write_mesh( ffo.str().c_str(), &m_overlap_set, 1 ) );
#endif
            // because we do not want to work with elements in coverage set that do not participate
            // in intersection, remove them from the coverage set we will not delete them yet, just
            // remove from the set !
            if( !point_cloud_target )
            {
                Range covEnts;
                MB_CHK_ERR( m_interface->get_entities_by_dimension( m_covering_source_set, 2, covEnts ) );
 
                std::map< int, int > loc_gid_to_lid_covsrc;
                std::vector< int > gids( covEnts.size(), -1 );
 
                Tag gidtag = m_interface->globalId_tag();
                MB_CHK_ERR( m_interface->tag_get_data( gidtag, covEnts, gids.data() ) );
 
                for( unsigned ie = 0; ie < gids.size(); ++ie )
                {
                    assert( gids[ie] > 0 );
                    loc_gid_to_lid_covsrc[gids[ie]] = ie;
                }
 
                Range intxCov, intxCells;
                Tag srcParentTag;
                MB_CHK_ERR( m_interface->tag_get_handle( "SourceParent", srcParentTag ) );
                MB_CHK_ERR( m_interface->get_entities_by_dimension( m_overlap_set, 2, intxCells ) );
                for( Range::iterator it = intxCells.begin(); it != intxCells.end(); ++it )
                {
                    EntityHandle intxCell = *it;
                    int srcParent         = -1;
                    MB_CHK_ERR( m_interface->tag_get_data( srcParentTag, &intxCell, 1, &srcParent ) );
 
                    assert( srcParent >= 0 );
                    intxCov.insert( covEnts[loc_gid_to_lid_covsrc[srcParent]] );
                }
 
                Range notNeededCovCells = moab::subtract( covEnts, intxCov );
 
                // now let us get only the covering entities that participate in intersection mesh
                covEnts = moab::subtract( covEnts, notNeededCovCells );
 
                // in order for getting 1-ring neighborhood, we need to be sure that the adjacencies are updated (created)
                if( false )
                {
                    // update all adjacency list
                    Core* mb                 = dynamic_cast< Core* >( m_interface );
                    AEntityFactory* adj_fact = mb->a_entity_factory();
                    if( !adj_fact->vert_elem_adjacencies() )
                        adj_fact->create_vert_elem_adjacencies();
                    else
                    {
                        for( Range::iterator it = covEnts.begin(); it != covEnts.end(); ++it )
                        {
                            EntityHandle eh          = *it;
                            const EntityHandle* conn = nullptr;
                            int num_nodes            = 0;
                            MB_CHK_ERR( mb->get_connectivity( eh, conn, num_nodes ) );
                            adj_fact->notify_create_entity( eh, conn, num_nodes );
                        }
                    }
 
                    // next, for elements on the edge of the partition, get one ring adjacencies
                    Skinner skinner( mb );
                    Range skin;
                    MB_CHK_SET_ERR( skinner.find_skin( m_covering_source_set, covEnts, false, skin ),
                                    "Unable to find skin" );
                    for( Range::iterator it = skin.begin(); it != skin.end(); ++it )
                    {
                        const EntityHandle* conn = nullptr;
                        int len                  = 0;
                        MB_CHK_ERR( mb->get_connectivity( *it, conn, len, false ) );
                        for( int ie = 0; ie < len; ++ie )
                        {
                            std::vector< EntityHandle > adjacent_entities;
                            MB_CHK_ERR( adj_fact->get_adjacencies( conn[ie], 2, false, adjacent_entities ) );
                            for( auto ent : adjacent_entities )
                                notNeededCovCells.erase( ent );  // ent is part of the 1-ring neighborhood
                        }
                    }
 
                    MB_CHK_ERR( m_interface->write_mesh(
                        std::string( "sourcecoveragemesh_p" + std::to_string( rank ) + ".h5m" ).c_str(),
                        &m_covering_source_set, 1 ) );
                }
 
                // remove now from coverage set the cells that are not needed
                // MB_CHK_ERR( m_interface->remove_entities( m_covering_source_set, notNeededCovCells ) );
 
                // Need to loop over covEnts now and ensure at least N-rings are available dependign on whether bilinear (1) or
                // high order FV (p) methods are being used for map generation. For bilinear/FV(1): need 1 ring, and for FV(p)
                // need p=ring neighborhood to recover exact conservation and consistency wrt serial/parallel.
#ifdef VERBOSE
                std::cout << " total participating elements in the covering set: " << intxCov.size() << "\n";
                std::cout << " remove from coverage set elements that are not intersected: " << notNeededCovCells.size()
                          << "\n";
#endif
                if( size > 1 )
                {
                    // some source elements cover multiple target partitions; the conservation logic
                    // requires to know all overlap elements for a source element; they need to be
                    // communicated from the other target partitions
                    //
                    // so first we have to identify source (coverage) elements that cover multiple
                    // target partitions
                    //
                    // we will then mark the source, we will need to migrate the overlap elements
                    // that cover this to the original source for the source element; then
                    // distribute the overlap elements to all processors that have the coverage mesh
                    // used
                    MB_CHK_ERR( AugmentOverlapSet() );
                }
            }
        }
#endif
 
        // Fix any inconsistencies in the overlap mesh
        {
            IntxAreaUtils areaAdaptor( m_area_method );
            MB_CHK_ERR( IntxUtils::fix_degenerate_quads( m_interface, m_overlap_set ) );
            MB_CHK_ERR( areaAdaptor.positive_orientation( m_interface, m_overlap_set, 1.0 /*radius*/ ) );
        }
 
        // free the memory
        delete mbintx;
    }
 
    // Now, let us convert the overlap mesh to MOAB format so that we have a consistent interface
    MB_CHK_SET_ERR( ConvertOverlapMeshSourceOrdered(), "Can't convert overlap TempestRemap mesh to MOAB format" );
 
    return MB_SUCCESS;
}

References AugmentOverlapSet(), moab::Range::begin(), ConvertOverlapMeshSourceOrdered(), moab::AEntityFactory::create_vert_elem_adjacencies(), dbgprint, moab::Range::end(), moab::Range::erase(), moab::Skinner::find_skin(), moab::IntxUtils::fix_degenerate_quads(), moab::AEntityFactory::get_adjacencies(), moab::Interface::get_entities_by_dimension(), moab::Interface::globalId_tag(), moab::Range::insert(), moab::Intx2Mesh::intersect_meshes(), moab::Intx2Mesh::intersect_meshes_kdtree(), is_parallel, m_area_method, m_covering_source, m_covering_source_set, moab::Remapper::m_interface, m_overlap, m_overlap_set, m_target, m_target_set, mb, MB_CHK_ERR, MB_CHK_SET_ERR, MB_SUCCESS, mbintx, moab::AEntityFactory::notify_create_entity(), point_cloud_target, moab::IntxAreaUtils::positive_orientation(), rank, moab::DebugOutput::set_prefix(), moab::Range::size(), size, moab::subtract(), moab::Interface::tag_get_data(), moab::Interface::tag_get_handle(), moab::AEntityFactory::vert_elem_adjacencies(), and moab::Interface::write_mesh().

Referenced by main().

ConstructCoveringSet()

ErrorCode moab::TempestRemapper::ConstructCoveringSet	(	double	tolerance = 1e-8,
		double	radius_src = 1.0,
		double	radius_tgt = 1.0,
		double	boxeps = 0.1,
		bool	regional_mesh = false,
		bool	gnomonic = true,
		int	nb_ghost_layers = 0
	)

Construct a source covering mesh such that it completely encompasses the target grid in parallel. This operation is critical to ensure that the parallel advancing-front intersection algorithm can compute the intersection mesh only locally without any process communication.

Parameters

tolerance	Tolerance for the covering mesh construction (default: 1e-8)
radius_src	Radius of the source mesh (default: 1.0)
radius_tgt	Radius of the target mesh (default: 1.0)
boxeps	Box epsilon value (default: 0.1)
regional_mesh	Flag to indicate if the mesh is regional (default: false)
gnomonic	Flag to indicate if the mesh is gnomonic (default: true)
nb_ghost_layers	Number of ghost layers (default: 0)

Returns

ErrorCode indicating the status of the covering mesh construction

Definition at line 1362 of file TempestRemapper.cpp.

{
    if( nb_ghost_layers >= 1 ) gnomonic = false;
    rrmgrids = regional_mesh;
    moab::Range local_verts;
 
    // Fail fast on meshes whose GLOBAL_IDs cannot support the coverage migration or
    // the map assembly.  Doing this before any expensive work turns what used to be a
    // silent corruption (collapsed cells, bogus map rows) into an immediate diagnosis.
    MB_CHK_ERR( ValidateGlobalIds() );
 
    // Initialize intersection context
    // Use the remapper-wide area formula rather than a hardcoded one, so that a single
    // choice (see SetAreaMethod) governs intersection, coverage and orientation fixups.
    mbintx = new moab::Intx2MeshOnSphere( m_interface, m_area_method );
 
    mbintx->set_error_tolerance( tolerance );
    mbintx->set_radius_source_mesh( radius_src );
    mbintx->set_radius_destination_mesh( radius_tgt );
    mbintx->set_box_error( boxeps );
#ifdef MOAB_HAVE_MPI
    mbintx->set_parallel_comm( m_pcomm );
#endif
 
    // compute the maxiumum edges in elements comprising source and target mesh
    MB_CHK_ERR( mbintx->FindMaxEdges( m_source_set, m_target_set ) );
 
    this->max_source_edges = mbintx->max_edges_1;
    this->max_target_edges = mbintx->max_edges_2;
 
    // Note: lots of communication possible, if mesh is distributed very differently
#ifdef MOAB_HAVE_MPI
    if( is_parallel )
    {
        MB_CHK_ERR( mbintx->build_processor_euler_boxes( m_target_set, local_verts, gnomonic ) );
 
        MB_CHK_SET_ERR( m_interface->create_meshset( moab::MESHSET_SET, m_covering_source_set ),
                        "Can't create new set" );
 
        MB_CHK_ERR( mbintx->construct_covering_set( m_source_set, m_covering_source_set, gnomonic, nb_ghost_layers ) );
#ifdef MOAB_DBG
        std::stringstream filename;
        filename << "covering" << rank << ".h5m";
        MB_CHK_ERR( m_interface->write_file( filename.str().c_str(), 0, 0, &m_covering_source_set, 1 ) );
        std::stringstream targetFile;
        targetFile << "target" << rank << ".h5m";
        MB_CHK_ERR( m_interface->write_file( targetFile.str().c_str(), 0, 0, &m_target_set, 1 ) );
#endif
    }
    else
    {
#endif
        // Serial: every source cell is trivially in the coverage set.
        //
        // A "regional mesh" shortcut used to live here, picking for each target vertex
        // the source cell with the nearest centroid.  Nearest centroid is not the same
        // relation as overlaps, so it dropped most of the covering set and produced a
        // silently wrong map (row sums down to 0.004).  Holes are handled where they
        // belong instead -- in the overlap-based area correction; see IsRegionalMesh().
        m_covering_source_set      = m_source_set;
        m_covering_source          = m_source;
        m_covering_source_entities = m_source_entities;  // this is a tempest mesh object; careful about
                                                         // incrementing the reference?
        m_covering_source_vertices = m_source_vertices;  // this is a tempest mesh object; careful about
                                                         // incrementing the reference?
#ifdef MOAB_HAVE_MPI
    }
#endif
 
    // Convert the source, target and coverage meshes to TempestRemap format
    MB_CHK_ERR( ConvertAllMeshesToTempest() );
 
    return moab::MB_SUCCESS;
}

References ConvertAllMeshesToTempest(), moab::Interface::create_meshset(), moab::Intx2Mesh::FindMaxEdges(), is_parallel, m_area_method, m_covering_source, m_covering_source_entities, m_covering_source_set, m_covering_source_vertices, moab::Remapper::m_interface, m_source, m_source_entities, m_source_set, m_source_vertices, m_target_set, moab::Intx2Mesh::max_edges_1, moab::Intx2Mesh::max_edges_2, max_source_edges, max_target_edges, MB_CHK_ERR, MB_CHK_SET_ERR, MB_SUCCESS, mbintx, MESHSET_SET, rank, rrmgrids, moab::Intx2Mesh::set_box_error(), moab::Intx2Mesh::set_error_tolerance(), moab::Intx2MeshOnSphere::set_radius_destination_mesh(), moab::Intx2MeshOnSphere::set_radius_source_mesh(), moab::tolerance, ValidateGlobalIds(), and moab::Interface::write_file().

Referenced by main().

convert_mesh_to_tempest_private()

ErrorCode moab::TempestRemapper::convert_mesh_to_tempest_private ( Mesh *  mesh, moab::EntityHandle  meshset, moab::Range &  entities, moab::Range *  pverts  )

private

Convert a MOAB mesh to TempestRemap format.

Parameters

mesh	Target TempestRemap mesh pointer
meshset	MOAB mesh set to convert
entities	Range of entities to convert
pverts	Optional pointer to vertex range

Returns

moab::ErrorCode Status of the conversion

Definition at line 642 of file TempestRemapper.cpp.

{
    NodeVector& nodes = mesh->nodes;
    FaceVector& faces = mesh->faces;
 
    elems.clear();
    MB_CHK_ERR( m_interface->get_entities_by_dimension( mesh_set, 2, elems ) );
 
    const size_t nelems = elems.size();
 
    // resize the number of elements in Tempest mesh
    faces.resize( nelems );
 
    // let us now get the vertices from all the elements
    Range verts;
    MB_CHK_ERR( m_interface->get_connectivity( elems, verts ) );
    if( verts.size() == 0 )
    {
        MB_CHK_ERR( m_interface->get_entities_by_dimension( mesh_set, 0, verts ) );
    }
    // assert(verts.size() > 0); // If not, this may be an invalid mesh ! possible for unbalanced loads
 
    std::map< EntityHandle, int > indxMap;
    bool useRange = true;
    if( verts.compactness() > 0.01 )
    {
        int j = 0;
        for( Range::iterator it = verts.begin(); it != verts.end(); ++it )
            indxMap[*it] = j++;
        useRange = false;
    }
 
    std::vector< int > globIds( nelems );
    moab::Tag gid = m_interface->globalId_tag();
    MB_CHK_ERR( m_interface->tag_get_data( gid, elems, &globIds[0] ) );
    std::vector< size_t > sortedIdx;
    if( offlineWorkflow )
    {
        sortedIdx.resize( nelems );
        // initialize original index locations
        std::iota( sortedIdx.begin(), sortedIdx.end(), 0 );
        // sort indexes based on comparing values in v, using std::stable_sort instead of std::sort
        // to avoid unnecessary index re-orderings when v contains elements of equal values
        std::sort( sortedIdx.begin(), sortedIdx.end(),
                   [&globIds]( size_t i1, size_t i2 ) { return globIds[i1] < globIds[i2]; } );
    }
 
    for( unsigned iface = 0; iface < nelems; ++iface )
    {
        Face& face           = faces[iface];
        EntityHandle ehandle = ( offlineWorkflow ? elems[sortedIdx[iface]] : elems[iface] );
 
        // get the connectivity for each edge
        const EntityHandle* connectface;
        int nnodesf;
        MB_CHK_ERR( m_interface->get_connectivity( ehandle, connectface, nnodesf ) );
        // account for padded polygons
        while( connectface[nnodesf - 2] == connectface[nnodesf - 1] && nnodesf > 3 )
            nnodesf--;
 
        face.edges.resize( nnodesf );
        for( int iverts = 0; iverts < nnodesf; ++iverts )
        {
            int indx = ( useRange ? verts.index( connectface[iverts] ) : indxMap[connectface[iverts]] );
            assert( indx >= 0 );
            face.SetNode( iverts, indx );
        }
    }
 
    unsigned nnodes = verts.size();
    nodes.resize( nnodes );
 
    // Set the data for the vertices
    std::vector< double > coordx( nnodes ), coordy( nnodes ), coordz( nnodes );
    MB_CHK_ERR( m_interface->get_coords( verts, &coordx[0], &coordy[0], &coordz[0] ) );
    for( unsigned inode = 0; inode < nnodes; ++inode )
    {
        Node& node = nodes[inode];
        node.x     = coordx[inode];
        node.y     = coordy[inode];
        node.z     = coordz[inode];
    }
    coordx.clear();
    coordy.clear();
    coordz.clear();
 
    mesh->RemoveCoincidentNodes();
    mesh->RemoveZeroEdges();
 
    // Generate reverse node array and edge map
    if( constructEdgeMap ) mesh->ConstructEdgeMap( false );
    // mesh->ConstructReverseNodeArray();
 
    // mesh->Validate();
 
    if( pverts )
    {
        pverts->clear();
        *pverts = verts;
    }
    verts.clear();
 
    return MB_SUCCESS;
}

References moab::Range::begin(), moab::Range::clear(), moab::Range::compactness(), constructEdgeMap, moab::Range::end(), moab::Interface::get_connectivity(), moab::Interface::get_coords(), moab::Interface::get_entities_by_dimension(), moab::Interface::globalId_tag(), iface, moab::Range::index(), moab::Remapper::m_interface, MB_CHK_ERR, MB_SUCCESS, offlineWorkflow, moab::Range::size(), and moab::Interface::tag_get_data().

Referenced by ConvertMeshToTempest(), and ResetMeshSet().

convert_tempest_mesh_private()

ErrorCode moab::TempestRemapper::convert_tempest_mesh_private ( TempestMeshType  type, Mesh *  mesh, moab::EntityHandle &  meshset, moab::Range &  entities, moab::Range *  vertices  )

private

Convert a TempestRemap mesh to MOAB format.

Parameters

type	Type of the TempestRemap mesh
mesh	Source TempestRemap mesh
meshset	Target MOAB mesh set
entities	Range to store converted entities
vertices	Optional range to store vertices

Returns

moab::ErrorCode Status of the conversion

Definition at line 252 of file TempestRemapper.cpp.

{
    const bool outputEnabled = ( TempestRemapper::verbose && is_root );
    const NodeVector& nodes  = mesh->nodes;
    const FaceVector& faces  = mesh->faces;
 
    moab::DebugOutput dbgprint( std::cout, this->rank, 0 );
    dbgprint.set_prefix( "[TempestToMOAB]: " );
 
    ReadUtilIface* iface;
    MB_CHK_SET_ERR( m_interface->query_interface( iface ), "Can't get reader interface" );
 
    Tag gidTag = m_interface->globalId_tag();
 
    // Set the data for the vertices
    std::vector< double* > arrays;
    std::vector< int > gidsv( nodes.size() );
    EntityHandle startv;
    MB_CHK_SET_ERR( iface->get_node_coords( 3, nodes.size(), 0, startv, arrays ), "Can't get node coords" );
    for( unsigned iverts = 0; iverts < nodes.size(); ++iverts )
    {
        const Node& node  = nodes[iverts];
        arrays[0][iverts] = node.x;
        arrays[1][iverts] = node.y;
        arrays[2][iverts] = node.z;
        gidsv[iverts]     = iverts + 1;
    }
    Range mbverts( startv, startv + nodes.size() - 1 );
    MB_CHK_SET_ERR( m_interface->add_entities( mesh_set, mbverts ), "Can't add entities" );
    MB_CHK_SET_ERR( m_interface->tag_set_data( gidTag, mbverts, &gidsv[0] ), "Can't set global_id tag" );
 
    gidsv.clear();
    entities.clear();
 
    Tag srcParentTag, tgtParentTag;
    std::vector< int > srcParent( faces.size(), -1 ), tgtParent( faces.size(), -1 );
    std::vector< int > gidse( faces.size(), -1 );
    bool storeParentInfo = ( mesh->vecSourceFaceIx.size() > 0 );
 
    if( storeParentInfo )
    {
        int defaultInt = -1;
        MB_CHK_SET_ERR( m_interface->tag_get_handle( "TargetParent", 1, MB_TYPE_INTEGER, tgtParentTag,
                                                     MB_TAG_DENSE | MB_TAG_CREAT, &defaultInt ),
                        "can't create positive tag" );
 
        MB_CHK_SET_ERR( m_interface->tag_get_handle( "SourceParent", 1, MB_TYPE_INTEGER, srcParentTag,
                                                     MB_TAG_DENSE | MB_TAG_CREAT, &defaultInt ),
                        "can't create negative tag" );
    }
 
    // Let us first perform a full pass assuming arbitrary polygons. This is especially true for
    // overlap meshes.
    //   1. We do a first pass over faces, decipher edge size and group into categories based on
    //   element type
    //   2. Next we loop over type, and add blocks of elements into MOAB
    //   3. For each block within the loop, also update the connectivity of elements.
    {
        if( outputEnabled )
            dbgprint.printf( 0, "..Mesh size: Nodes [%zu]  Elements [%zu].\n", nodes.size(), faces.size() );
        std::vector< EntityHandle > mbcells( faces.size() );
        unsigned ntris = 0, nquads = 0, npolys = 0;
        std::vector< EntityHandle > conn( 16 );
 
        for( unsigned ifaces = 0; ifaces < faces.size(); ++ifaces )
        {
            const Face& face              = faces[ifaces];
            const unsigned num_v_per_elem = face.edges.size();
 
            for( unsigned iedges = 0; iedges < num_v_per_elem; ++iedges )
            {
                conn[iedges] = startv + face.edges[iedges].node[0];
            }
 
            switch( num_v_per_elem )
            {
                case 3:
                    // if( outputEnabled )
                    //     dbgprint.printf( 0, "....Block %d: Triangular Elements [%u].\n", iBlock++, nPolys[iType] );
                    MB_CHK_SET_ERR( m_interface->create_element( MBTRI, &conn[0], num_v_per_elem, mbcells[ifaces] ),
                                    "Can't get element connectivity" );
                    ntris++;
                    break;
                case 4:
                    // if( outputEnabled )
                    //     dbgprint.printf( 0, "....Block %d: Quadrilateral Elements [%u].\n", iBlock++, nPolys[iType] );
                    MB_CHK_SET_ERR( m_interface->create_element( MBQUAD, &conn[0], num_v_per_elem, mbcells[ifaces] ),
                                    "Can't get element connectivity" );
                    nquads++;
                    break;
                default:
                    // if( outputEnabled )
                    //     dbgprint.printf( 0, "....Block %d: Polygonal [%u] Elements [%u].\n", iBlock++, iType,
                    //                      nPolys[iType] );
                    MB_CHK_SET_ERR( m_interface->create_element( MBPOLYGON, &conn[0], num_v_per_elem, mbcells[ifaces] ),
                                    "Can't get element connectivity" );
                    npolys++;
                    break;
            }
 
            gidse[ifaces] = ifaces + 1;
 
            if( storeParentInfo )
            {
                srcParent[ifaces] = mesh->vecSourceFaceIx[ifaces] + 1;
                tgtParent[ifaces] = mesh->vecTargetFaceIx[ifaces] + 1;
            }
        }
 
        if( ntris ) dbgprint.printf( 0, "....Triangular Elements [%u].\n", ntris );
        if( nquads ) dbgprint.printf( 0, "....Quadrangular Elements [%u].\n", nquads );
        if( npolys ) dbgprint.printf( 0, "....Polygonal Elements [%u].\n", npolys );
 
        MB_CHK_SET_ERR( m_interface->add_entities( mesh_set, &mbcells[0], mbcells.size() ), "Could not add entities" );
 
        MB_CHK_SET_ERR( m_interface->tag_set_data( gidTag, &mbcells[0], mbcells.size(), &gidse[0] ),
                        "Can't set global_id tag" );
#ifdef MOAB_HAVE_MPI
        MB_CHK_SET_ERR( m_pcomm->assign_global_ids(mesh_set, 2, 1, false, true, false ), "Unable to set global IDs" );
#endif
 
        if( storeParentInfo )
        {
            MB_CHK_SET_ERR( m_interface->tag_set_data( srcParentTag, &mbcells[0], mbcells.size(), &srcParent[0] ),
                            "Can't set tag data" );
            MB_CHK_SET_ERR( m_interface->tag_set_data( tgtParentTag, &mbcells[0], mbcells.size(), &tgtParent[0] ),
                            "Can't set tag data" );
        }
 
        // insert from mbcells to entities to preserve ordering
        std::copy( mbcells.begin(), mbcells.end(), range_inserter( entities ) );
    }
 
    if( vertices ) *vertices = mbverts;
 
    return MB_SUCCESS;
}

References moab::Interface::add_entities(), moab::Range::clear(), moab::Interface::create_element(), dbgprint, moab::Interface::globalId_tag(), iface, is_root, moab::Remapper::m_interface, MB_CHK_SET_ERR, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TYPE_INTEGER, MBPOLYGON, MBQUAD, MBTRI, moab::Interface::query_interface(), rank, moab::DebugOutput::set_prefix(), moab::Interface::tag_get_handle(), moab::Interface::tag_set_data(), and verbose.

Referenced by ConvertTempestMesh().

ConvertAllMeshesToTempest()

ErrorCode moab::TempestRemapper::ConvertAllMeshesToTempest ( )

private

Convert all MOAB meshes to TempestRemap format.

Utility method primarily used in online workflows to convert all meshes to TempestRemap format.

Returns

ErrorCode Status of the conversion

Definition at line 564 of file TempestRemapper.cpp.

{
    // now, let us ensure we have a valid source and target mesh objects
    // if not, convert the source and target meshes to TempestRemap format
    if( this->m_source == nullptr )
    {
        // Convert the covering mesh to TempestRemap format
        MB_CHK_SET_ERR( this->ConvertMeshToTempest( moab::Remapper::SourceMesh ),
                        "Can't convert source mesh to TempestRemap format" );
    }
    if( this->m_covering_source == nullptr )
    {
        // Convert the covering mesh to TempestRemap format
        MB_CHK_SET_ERR( this->ConvertMeshToTempest( moab::Remapper::CoveringMesh ),
                        "Can't convert source coverage mesh to TempestRemap format" );
    }
    if( this->m_target == nullptr )
    {
        // Convert the covering mesh to TempestRemap format
        MB_CHK_SET_ERR( this->ConvertMeshToTempest( moab::Remapper::TargetMesh ),
                        "Can't convert target mesh to TempestRemap format" );
    }
 
    return moab::MB_SUCCESS;
}

References ConvertMeshToTempest(), moab::Remapper::CoveringMesh, m_covering_source, m_source, m_target, MB_CHK_SET_ERR, MB_SUCCESS, moab::Remapper::SourceMesh, and moab::Remapper::TargetMesh.

Referenced by ConstructCoveringSet().

ConvertMeshToTempest()

ErrorCode moab::TempestRemapper::ConvertMeshToTempest

(

Remapper::IntersectionContext

ctx

)

Convert the MOAB mesh representation to a corresponding TempestRemap mesh object according to the intersection context.

Parameters

ctx	Intersection context

Returns

ErrorCode indicating the status of the mesh conversion

Definition at line 590 of file TempestRemapper.cpp.

{
    const bool outputEnabled = ( TempestRemapper::verbose && is_root );
 
    // create a debug output object and set a prefix
    moab::DebugOutput dbgprint( std::cout, this->rank, 0 );
    dbgprint.set_prefix( "[MOABToTempest]: " );
 
    if( ctx == Remapper::SourceMesh )
    {
        if( !m_source ) m_source = new Mesh();
        if( outputEnabled ) dbgprint.printf( 0, "Converting (source) MOAB to TempestRemap Mesh representation ...\n" );
        MB_CHK_SET_ERR( convert_mesh_to_tempest_private( m_source, m_source_set, m_source_entities,
                                                         &m_source_vertices ),
                        "Can't convert source mesh to Tempest" );
        if( m_source_entities.size() == 0 && m_source_vertices.size() != 0 )
        {
            this->point_cloud_source = true;
        }
    }
    else if( ctx == Remapper::CoveringMesh )
    {
        if( !m_covering_source ) m_covering_source = new Mesh();
        if( outputEnabled )
            dbgprint.printf( 0, "Converting (covering source) MOAB to TempestRemap Mesh representation ...\n" );
        MB_CHK_SET_ERR( convert_mesh_to_tempest_private( m_covering_source, m_covering_source_set,
                                                         m_covering_source_entities, &m_covering_source_vertices ),
                        "Can't convert convering source mesh to TempestRemap format" );
    }
    else if( ctx == Remapper::TargetMesh )
    {
        if( !m_target ) m_target = new Mesh();
        if( outputEnabled ) dbgprint.printf( 0, "Converting (target) MOAB to TempestRemap Mesh representation ...\n" );
        MB_CHK_SET_ERR( convert_mesh_to_tempest_private( m_target, m_target_set, m_target_entities,
                                                         &m_target_vertices ),
                        "Can't convert target mesh to Tempest" );
        if( m_target_entities.size() == 0 && m_target_vertices.size() != 0 ) this->point_cloud_target = true;
    }
    else if( ctx == Remapper::OverlapMesh )  // Overlap mesh
    {
        if( !m_overlap ) m_overlap = new Mesh();
        if( outputEnabled ) dbgprint.printf( 0, "Converting (overlap) MOAB to TempestRemap Mesh representation ...\n" );
        MB_CHK_SET_ERR( ConvertOverlapMeshSourceOrdered(), "Can't convert overlap mesh to Tempest" );
    }
    else
    {
        MB_CHK_SET_ERR( MB_FAILURE, "Invalid IntersectionContext context provided" );
    }
 
    return moab::MB_SUCCESS;
}

References convert_mesh_to_tempest_private(), ConvertOverlapMeshSourceOrdered(), moab::Remapper::CoveringMesh, dbgprint, is_root, m_covering_source, m_covering_source_entities, m_covering_source_set, m_covering_source_vertices, m_overlap, m_source, m_source_entities, m_source_set, m_source_vertices, m_target, m_target_entities, m_target_set, m_target_vertices, MB_CHK_SET_ERR, MB_SUCCESS, moab::Remapper::OverlapMesh, point_cloud_source, point_cloud_target, rank, moab::DebugOutput::set_prefix(), moab::Range::size(), moab::Remapper::SourceMesh, moab::Remapper::TargetMesh, and verbose.

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

ConvertOverlapMeshSourceOrdered()

ErrorCode moab::TempestRemapper::ConvertOverlapMeshSourceOrdered ( )

private

Convert overlap mesh to source-ordered format.

Transforms the overlap mesh into a source-ordered format compatible with TempestRemap.

Returns

moab::ErrorCode Status of the conversion

Definition at line 799 of file TempestRemapper.cpp.

{
    m_overlap_entities.clear();
    MB_CHK_ERR( m_interface->get_entities_by_dimension( m_overlap_set, 2, m_overlap_entities ) );
    size_t n_overlap_entitites = m_overlap_entities.size();
 
    // Allocate for the overlap mesh
    if( !m_overlap ) m_overlap = new Mesh();
 
    std::vector< std::array< int, 3 > > sorted_overlap_order( n_overlap_entitites,
                                                              std::array< int, 3 >( { -1, -1, -1 } ) );
    {
        Tag srcParentTag, tgtParentTag;
        MB_CHK_ERR( m_interface->tag_get_handle( "SourceParent", srcParentTag ) );
        MB_CHK_ERR( m_interface->tag_get_handle( "TargetParent", tgtParentTag ) );
        // Overlap mesh: resize the source and target connection arrays
        m_overlap->vecTargetFaceIx.resize( n_overlap_entitites );
        m_overlap->vecSourceFaceIx.resize( n_overlap_entitites );
 
        // We need a global to local numbering
        Tag gidtag = m_interface->globalId_tag();
        std::vector< int > gids_src( m_covering_source_entities.size(), -1 ), gids_tgt( m_target_entities.size(), -1 );
        MB_CHK_ERR( m_interface->tag_get_data( gidtag, m_covering_source_entities, gids_src.data() ) );
        MB_CHK_ERR( m_interface->tag_get_data( gidtag, m_target_entities, gids_tgt.data() ) );
 
        // Global-id -> local-index lookup.
        //
        // This used to be a std::find() over the whole gid vector for every overlap
        // element, making the loop below O(n_overlap * n_source).  On a 288k-cell RLL
        // source that single std::find accounted for 68% of total runtime (13029 of
        // 19243 samples).  Build the index once instead, so each lookup is O(1) and
        // the loop becomes O(n_overlap + n_source).
        //
        // Insert with first-occurrence-wins so the result matches what std::find
        // returned when a global id appears more than once.
        auto build_index = []( const std::vector< int >& gids ) {
            std::unordered_map< int, int > index;
            index.reserve( gids.size() * 2 );
            for( size_t i = 0; i < gids.size(); i++ )
                index.emplace( gids[i], static_cast< int >( i ) );
            return index;
        };
 
        std::unordered_map< int, int > index_src, index_tgt;
        if( !offlineWorkflow )
        {
            index_src = build_index( gids_src );
            index_tgt = build_index( gids_tgt );
        }
 
        auto find_lid = [this]( const std::unordered_map< int, int >& index, int gid ) -> int {
            if( offlineWorkflow ) return gid - 1;
            auto it = index.find( gid );
            return ( it != index.end() ? it->second : -1 );
        };
 
        std::vector< int > ghFlags;
        if( is_parallel )
        {
            Tag ghostTag;
            ghFlags.resize( n_overlap_entitites );
            MB_CHK_SET_ERR( m_interface->tag_get_handle( "ORIG_PROC", ghostTag ), "Could not find ORIG_PROC tag" );
            MB_CHK_ERR( m_interface->tag_get_data( ghostTag, m_overlap_entities, ghFlags.data() ) );
        }
 
        // Overlap mesh: resize the source and target connection arrays
        std::vector< int > rbids_src( n_overlap_entitites ), rbids_tgt( n_overlap_entitites );
        MB_CHK_ERR( m_interface->tag_get_data( srcParentTag, m_overlap_entities, rbids_src.data() ) );
        MB_CHK_ERR( m_interface->tag_get_data( tgtParentTag, m_overlap_entities, rbids_tgt.data() ) );
 
        for( size_t ix = 0; ix < n_overlap_entitites; ++ix )
        {
            std::get< 0 >( sorted_overlap_order[ix] ) = ix;
            std::get< 1 >( sorted_overlap_order[ix] ) = find_lid( index_src, rbids_src[ix] );
            assert( std::get< 1 >( sorted_overlap_order[ix] ) >= 0 );
            if( is_parallel && ghFlags[ix] >= 0 )
            {
                // Ghost overlap element: its target cell lives on the rank that owns this element.
                // Weight contributions for this element are computed on that owning rank (where the
                // element has ORIG_PROC=-1 and a valid local target face index).  Using -1 here
                // ensures the element is skipped on this rank to avoid double-counting.
                std::get< 2 >( sorted_overlap_order[ix] ) = -1;
            }
            else
                std::get< 2 >( sorted_overlap_order[ix] ) = find_lid( index_tgt, rbids_tgt[ix] );
        }
        // now sort the overlap elements such that they are ordered by source parent first
        // and then target parent next
        std::sort( sorted_overlap_order.begin(), sorted_overlap_order.end(), IntPairComparator );
 
        for( unsigned ie = 0; ie < n_overlap_entitites; ++ie )
        {
            m_overlap->vecSourceFaceIx[ie] = std::get< 1 >( sorted_overlap_order[ie] );
            m_overlap->vecTargetFaceIx[ie] = std::get< 2 >( sorted_overlap_order[ie] );
        }
    }
 
    FaceVector& faces = m_overlap->faces;
    faces.resize( n_overlap_entitites );
 
    Range verts;
    // let us now get the vertices from all the elements
    MB_CHK_ERR( m_interface->get_connectivity( m_overlap_entities, verts ) );
 
    std::map< EntityHandle, int > indxMap;
    {
        int j = 0;
        for( Range::iterator it = verts.begin(); it != verts.end(); ++it )
            indxMap[*it] = j++;
    }
 
    for( unsigned ifac = 0; ifac < m_overlap_entities.size(); ++ifac )
    {
        const unsigned iface = std::get< 0 >( sorted_overlap_order[ifac] );
        Face& face           = faces[ifac];
        EntityHandle ehandle = m_overlap_entities[iface];
 
        // get the connectivity for each edge
        const EntityHandle* connectface;
        int nnodesf;
        MB_CHK_ERR( m_interface->get_connectivity( ehandle, connectface, nnodesf ) );
 
        face.edges.resize( nnodesf );
        for( int iverts = 0; iverts < nnodesf; ++iverts )
        {
            int indx = indxMap[connectface[iverts]];
            assert( indx >= 0 );
            face.SetNode( iverts, indx );
        }
    }
    indxMap.clear();
    sorted_overlap_order.clear();
 
    unsigned nnodes   = verts.size();
    NodeVector& nodes = m_overlap->nodes;
    nodes.resize( nnodes );
 
    // Set the data for the vertices
    std::vector< double > coordx( nnodes ), coordy( nnodes ), coordz( nnodes );
    MB_CHK_ERR( m_interface->get_coords( verts, &coordx[0], &coordy[0], &coordz[0] ) );
    for( unsigned inode = 0; inode < nnodes; ++inode )
    {
        Node& node = nodes[inode];
        node.x     = coordx[inode];
        node.y     = coordy[inode];
        node.z     = coordz[inode];
    }
    coordx.clear();
    coordy.clear();
    coordz.clear();
    verts.clear();
 
    // ideally, we should do these in MOAB after intersction computation
    // m_overlap->RemoveZeroEdges();
    // m_overlap->RemoveCoincidentNodes( false );
 
    // Generate reverse node array and edge map
    // if ( constructEdgeMap ) m_overlap->ConstructEdgeMap(false);
    // m_overlap->ConstructReverseNodeArray();
 
    // For now, comment out validation; not needed
    // m_overlap->Validate();
 
    // all done. return success
    return MB_SUCCESS;
}

References moab::Range::begin(), moab::Range::clear(), moab::Range::end(), moab::Interface::get_connectivity(), moab::Interface::get_coords(), moab::Interface::get_entities_by_dimension(), moab::Interface::globalId_tag(), iface, moab::index, moab::IntPairComparator(), is_parallel, m_covering_source_entities, moab::Remapper::m_interface, m_overlap, m_overlap_entities, m_overlap_set, m_target_entities, MB_CHK_ERR, MB_CHK_SET_ERR, MB_SUCCESS, offlineWorkflow, moab::Range::size(), moab::Interface::tag_get_data(), and moab::Interface::tag_get_handle().

Referenced by ComputeOverlapMesh(), and ConvertMeshToTempest().

ConvertTempestMesh()

ErrorCode moab::TempestRemapper::ConvertTempestMesh

(

Remapper::IntersectionContext

ctx

)

Convert the TempestRemap mesh object to a corresponding MOAB mesh representation according to the intersection context.

Parameters

ctx	Intersection context

Returns

ErrorCode indicating the status of the mesh conversion

Definition at line 223 of file TempestRemapper.cpp.

{
    const bool outputEnabled = ( TempestRemapper::verbose && is_root );
    if( ctx == Remapper::SourceMesh )
    {
        if( outputEnabled ) std::cout << "Converting (source) TempestRemap Mesh object to MOAB representation ...\n";
        return convert_tempest_mesh_private( m_source_type, m_source, m_source_set, m_source_entities,
                                             &m_source_vertices );
    }
    else if( ctx == Remapper::TargetMesh )
    {
        if( outputEnabled ) std::cout << "Converting (target) TempestRemap Mesh object to MOAB representation ...\n";
        return convert_tempest_mesh_private( m_target_type, m_target, m_target_set, m_target_entities,
                                             &m_target_vertices );
    }
    else if( ctx != Remapper::DEFAULT )
    {
        if( outputEnabled ) std::cout << "Converting (overlap) TempestRemap Mesh object to MOAB representation ...\n";
        return convert_tempest_mesh_private( m_overlap_type, m_overlap, m_overlap_set, m_overlap_entities, nullptr );
    }
    else
    {
        MB_CHK_SET_ERR( MB_FAILURE, "Invalid IntersectionContext context provided" );
    }
}

References convert_tempest_mesh_private(), moab::Remapper::DEFAULT, is_root, m_overlap, m_overlap_entities, m_overlap_set, m_overlap_type, m_source, m_source_entities, m_source_set, m_source_type, m_source_vertices, m_target, m_target_entities, m_target_set, m_target_type, m_target_vertices, MB_CHK_SET_ERR, moab::Remapper::SourceMesh, moab::Remapper::TargetMesh, and verbose.

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

GenerateCSMeshMetadata()

ErrorCode moab::TempestRemapper::GenerateCSMeshMetadata	(	const int	ntot_elements,
		moab::Range &	entities,
		moab::Range *	secondary_entities,
		const std::string &	dofTagName,
		int	nP
	)

Generate the necessary metadata and specifically the GLL node numbering for DoFs for a CS mesh. This negates the need for running external code like HOMME to output the numbering needed for computing maps. The functionality is used through the mbconvert tool to compute processor-invariant Global DoF IDs at GLL nodes.

Parameters

ntot_elements	Total number of elements
entities	MOAB range of entities
secondary_entities	MOAB range of secondary entities (optional)
dofTagName	Name of the DoF tag
nP	Number of points

Returns

ErrorCode indicating the status of the metadata generation

Definition at line 1070 of file TempestRemapper.cpp.

{
    const int csResolution = std::sqrt( ntot_elements / 6.0 );
    if( csResolution * csResolution * 6 != ntot_elements ) return MB_INVALID_SIZE;
 
    // Create a temporary Cubed-Sphere mesh
    // NOTE: This will not work for RRM grids. Need to run HOMME for that case anyway
    Mesh csMesh;
    if( GenerateCSMesh( csMesh, csResolution, "", "NetCDF4" ) )
        MB_CHK_SET_ERR( moab::MB_FAILURE,  // unsuccessful call
                        "Failed to generate CS mesh through TempestRemap" );
 
    // let us now generate the mesh metadata
    if( this->GenerateMeshMetadata( csMesh, ntot_elements, ents, secondary_ents, dofTagName, nP ) )
        MB_CHK_SET_ERR( moab::MB_FAILURE, "Failed in call to GenerateMeshMetadata" );  // unsuccessful call
 
    return moab::MB_SUCCESS;
}

References GenerateMeshMetadata(), MB_CHK_SET_ERR, MB_INVALID_SIZE, and MB_SUCCESS.

GenerateMesh()

moab::ErrorCode moab::TempestRemapper::GenerateMesh	(	Remapper::IntersectionContext	ctx,
		TempestMeshType	type
	)

Generate a mesh in memory of given type (CS/RLL/ICO/MPAS(structured)) and store it under the context specified by the user.

Parameters

ctx	Intersection context
type	Type of mesh to generate

Returns

ErrorCode indicating the status of the mesh generation

GenerateMeshMetadata()

ErrorCode moab::TempestRemapper::GenerateMeshMetadata	(	Mesh &	mesh,
		const int	ntot_elements,
		moab::Range &	entities,
		moab::Range *	secondary_entities,
		const std::string &	dofTagName,
		int	nP
	)

Generate the necessary metadata for DoF node numbering in a given mesh. Currently, only the functionality to generate numbering on CS grids is supported.

Parameters

mesh	Mesh object
ntot_elements	Total number of elements
entities	MOAB range of entities
secondary_entities	MOAB range of secondary entities (optional)
dofTagName	Name of the DoF tag
nP	Number of points

Returns

ErrorCode indicating the status of the metadata generation

Definition at line 1093 of file TempestRemapper.cpp.

{
    Tag dofTag;
    bool created = false;
    MB_CHK_SET_ERR( m_interface->tag_get_handle( dofTagName.c_str(), nP * nP, MB_TYPE_INTEGER, dofTag,
                                                 MB_TAG_DENSE | MB_TAG_CREAT, 0, &created ),
                    "Failed creating DoF tag" );
 
    // Number of Faces
    int nElements = static_cast< int >( csMesh.faces.size() );
 
    if( nElements != ntot_elements ) return MB_INVALID_SIZE;
 
    // Initialize data structures
    DataArray3D< int > dataGLLnodes;
    dataGLLnodes.Allocate( nP, nP, nElements );
 
    std::map< Node, int > mapNodes;
    std::map< Node, moab::EntityHandle > mapLocalMBNodes;
 
    // GLL Quadrature nodes
    DataArray1D< double > dG;
    DataArray1D< double > dW;
    GaussLobattoQuadrature::GetPoints( nP, 0.0, 1.0, dG, dW );
 
    moab::Range entities( ents );
    if( secondary_ents ) entities.insert( secondary_ents->begin(), secondary_ents->end() );
    double elcoords[3];
    for( unsigned iel = 0; iel < entities.size(); ++iel )
    {
        EntityHandle eh = entities[iel];
        MB_CHK_SET_ERR( m_interface->get_coords( &eh, 1, elcoords ), "failed to get element coordinates" );
        Node elCentroid( elcoords[0], elcoords[1], elcoords[2] );
        mapLocalMBNodes.insert( std::pair< Node, moab::EntityHandle >( elCentroid, eh ) );
    }
 
    // Build a Kd-tree for local mesh (nearest neighbor searches)
    // Loop over all elements in CS-Mesh
    // Then find if current centroid is in an element
    //     If yes - then let us compute the DoF numbering and set to tag data
    //     If no - then compute DoF numbering BUT DO NOT SET to tag data
    // continue
    int* dofIDs = new int[nP * nP];
 
    // Write metadata
    for( int k = 0; k < nElements; k++ )
    {
        const Face& face        = csMesh.faces[k];
        const NodeVector& nodes = csMesh.nodes;
 
        if( face.edges.size() != 4 )
        {
            _EXCEPTIONT( "Mesh must only contain quadrilateral elements" );
        }
 
        Node centroid;
        centroid.x = centroid.y = centroid.z = 0.0;
        for( unsigned l = 0; l < face.edges.size(); ++l )
        {
            centroid.x += nodes[face[l]].x;
            centroid.y += nodes[face[l]].y;
            centroid.z += nodes[face[l]].z;
        }
        const double factor = 1.0 / face.edges.size();
        centroid.x *= factor;
        centroid.y *= factor;
        centroid.z *= factor;
 
        bool locElem = false;
        EntityHandle current_eh;
        if( mapLocalMBNodes.find( centroid ) != mapLocalMBNodes.end() )
        {
            locElem    = true;
            current_eh = mapLocalMBNodes[centroid];
        }
 
        for( int j = 0; j < nP; j++ )
        {
            for( int i = 0; i < nP; i++ )
            {
                // Get local map vectors
                Node nodeGLL;
                Node dDx1G;
                Node dDx2G;
 
                // ApplyLocalMap(
                //     face,
                //     nodevec,
                //     dG[i],
                //     dG[j],
                //     nodeGLL,
                //     dDx1G,
                //     dDx2G);
                const double& dAlpha = dG[i];
                const double& dBeta  = dG[j];
 
                // Calculate nodal locations on the plane
                double dXc = nodes[face[0]].x * ( 1.0 - dAlpha ) * ( 1.0 - dBeta ) +
                             nodes[face[1]].x * dAlpha * ( 1.0 - dBeta ) + nodes[face[2]].x * dAlpha * dBeta +
                             nodes[face[3]].x * ( 1.0 - dAlpha ) * dBeta;
 
                double dYc = nodes[face[0]].y * ( 1.0 - dAlpha ) * ( 1.0 - dBeta ) +
                             nodes[face[1]].y * dAlpha * ( 1.0 - dBeta ) + nodes[face[2]].y * dAlpha * dBeta +
                             nodes[face[3]].y * ( 1.0 - dAlpha ) * dBeta;
 
                double dZc = nodes[face[0]].z * ( 1.0 - dAlpha ) * ( 1.0 - dBeta ) +
                             nodes[face[1]].z * dAlpha * ( 1.0 - dBeta ) + nodes[face[2]].z * dAlpha * dBeta +
                             nodes[face[3]].z * ( 1.0 - dAlpha ) * dBeta;
 
                double dR = sqrt( dXc * dXc + dYc * dYc + dZc * dZc );
 
                // Mapped node location
                nodeGLL.x = dXc / dR;
                nodeGLL.y = dYc / dR;
                nodeGLL.z = dZc / dR;
 
                // Determine if this is a unique Node
                std::map< Node, int >::const_iterator iter = mapNodes.find( nodeGLL );
                if( iter == mapNodes.end() )
                {
                    // Insert new unique node into map
                    int ixNode = static_cast< int >( mapNodes.size() );
                    mapNodes.insert( std::pair< Node, int >( nodeGLL, ixNode ) );
                    dataGLLnodes[j][i][k] = ixNode + 1;
                }
                else
                {
                    dataGLLnodes[j][i][k] = iter->second + 1;
                }
 
                dofIDs[j * nP + i] = dataGLLnodes[j][i][k];
            }
        }
 
        if( locElem )
        {
            MB_CHK_SET_ERR( m_interface->tag_set_data( dofTag, &current_eh, 1, dofIDs ),
                            "Failed to tag_set_data for DoFs" );
        }
    }
 
    // clear memory
    delete[] dofIDs;
    mapLocalMBNodes.clear();
    mapNodes.clear();
 
    return moab::MB_SUCCESS;
}

References moab::Range::begin(), moab::Range::end(), moab::Interface::get_coords(), moab::Range::insert(), moab::Remapper::m_interface, MB_CHK_SET_ERR, MB_INVALID_SIZE, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TYPE_INTEGER, moab::Range::size(), moab::Interface::tag_get_handle(), and moab::Interface::tag_set_data().

Referenced by GenerateCSMeshMetadata(), and main().

GetAreaMethod()

IntxAreaUtils::AreaMethod moab::TempestRemapper::GetAreaMethod ( ) const

inline

Formula currently used for spherical area computations.

Definition at line 176 of file TempestRemapper.hpp.

    {
        return m_area_method;
    }

References m_area_method.

GetCoveringMesh()

Mesh * moab::TempestRemapper::GetCoveringMesh ( )

inline

Get the covering mesh (TempestRemap) object.

Returns

Pointer to the covering mesh object

Definition at line 834 of file TempestRemapper.hpp.

{
    return m_covering_source;
}

References m_covering_source.

Referenced by moab::TempestOnlineMap::TempestOnlineMap().

GetCoveringSet()

moab::EntityHandle & moab::TempestRemapper::GetCoveringSet ( )

inline

Get access to the underlying source covering set if available. Else return the source set.

Returns

MOAB entity handle of the covering set

Definition at line 839 of file TempestRemapper.hpp.

{
    return m_covering_source_set;
}

References m_covering_source_set.

GetIMasks()

ErrorCode moab::TempestRemapper::GetIMasks	(	Remapper::IntersectionContext	ctx,
		std::vector< int > &	masks
	)

Get the masks that could have been defined.

Parameters

ctx	Intersection context
masks	Vector of masks

Returns

ErrorCode indicating the status of the get operation

Definition at line 2252 of file TempestRemapper.cpp.

{
    Tag maskTag;
    // it should have been created already, if not, we might have a problem
    int def_val = 1;
    MB_CHK_SET_ERR( m_interface->tag_get_handle( "GRID_IMASK", 1, MB_TYPE_INTEGER, maskTag, MB_TAG_DENSE | MB_TAG_CREAT,
                                                 &def_val ),
                    "Trouble creating GRID_IMASK tag" );
 
    switch( ctx )
    {
        case Remapper::SourceMesh: {
            if( point_cloud_source )
            {
                masks.resize( m_source_vertices.size() );
                MB_CHK_SET_ERR( m_interface->tag_get_data( maskTag, m_source_vertices, &masks[0] ),
                                "Trouble getting GRID_IMASK tag" );
            }
            else
            {
                masks.resize( m_source_entities.size() );
                MB_CHK_SET_ERR( m_interface->tag_get_data( maskTag, m_source_entities, &masks[0] ),
                                "Trouble getting GRID_IMASK tag" );
            }
            return MB_SUCCESS;
        }
        case Remapper::TargetMesh: {
            if( point_cloud_target )
            {
                masks.resize( m_target_vertices.size() );
                MB_CHK_SET_ERR( m_interface->tag_get_data( maskTag, m_target_vertices, &masks[0] ),
                                "Trouble getting GRID_IMASK tag" );
            }
            else
            {
                masks.resize( m_target_entities.size() );
                MB_CHK_SET_ERR( m_interface->tag_get_data( maskTag, m_target_entities, &masks[0] ),
                                "Trouble getting GRID_IMASK tag" );
            }
            return MB_SUCCESS;
        }
        case Remapper::CoveringMesh:
        case Remapper::OverlapMesh:
        default:
            return MB_SUCCESS;
    }
}

References moab::Remapper::CoveringMesh, moab::Remapper::m_interface, m_source_entities, m_source_vertices, m_target_entities, m_target_vertices, MB_CHK_SET_ERR, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TYPE_INTEGER, moab::Remapper::OverlapMesh, point_cloud_source, point_cloud_target, moab::Range::size(), moab::Remapper::SourceMesh, moab::Interface::tag_get_data(), moab::Interface::tag_get_handle(), and moab::Remapper::TargetMesh.

GetMesh()

Mesh * moab::TempestRemapper::GetMesh ( Remapper::IntersectionContext  ctx )

inline

Get the TempestRemap mesh object according to the intersection context.

Parameters

ctx	Intersection context

Returns

Pointer to the TempestRemap mesh object

Definition at line 601 of file TempestRemapper.hpp.

{
    switch( ctx )
    {
        case Remapper::SourceMesh:
            return m_source;
        case Remapper::TargetMesh:
            return m_target;
        case Remapper::OverlapMesh:
            return m_overlap;
        case Remapper::CoveringMesh:
            return m_covering_source;
        case Remapper::DEFAULT:
        default:
            return NULL;
    }
}

References moab::Remapper::CoveringMesh, moab::Remapper::DEFAULT, m_covering_source, m_overlap, m_source, m_target, moab::Remapper::OverlapMesh, moab::Remapper::SourceMesh, and moab::Remapper::TargetMesh.

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

GetMeshEntities() [1/2]

moab::Range & moab::TempestRemapper::GetMeshEntities ( Remapper::IntersectionContext  ctx )

inline

Get the mesh element entities corresponding to the intersection context.

Parameters

ctx	Intersection context

Returns

MOAB range of mesh element entities

Definition at line 711 of file TempestRemapper.hpp.

{
    switch( ctx )
    {
        case Remapper::SourceMesh:
            return m_source_entities;
        case Remapper::TargetMesh:
            return m_target_entities;
        case Remapper::OverlapMesh:
            return m_overlap_entities;
        case Remapper::CoveringMesh:
            return m_covering_source_entities;
        case Remapper::DEFAULT:
        default:
            MB_SET_ERR_RET_VAL( "Invalid context passed to GetMeshSet", m_overlap_entities );
    }
}

References moab::Remapper::CoveringMesh, moab::Remapper::DEFAULT, m_covering_source_entities, m_overlap_entities, m_source_entities, m_target_entities, MB_SET_ERR_RET_VAL, moab::Remapper::OverlapMesh, moab::Remapper::SourceMesh, and moab::Remapper::TargetMesh.

Referenced by main().

GetMeshEntities() [2/2]

const moab::Range & moab::TempestRemapper::GetMeshEntities ( Remapper::IntersectionContext  ctx ) const

inline

Const overload. Get the mesh element entities corresponding to the intersection context.

Parameters

ctx	Intersection context

Returns

MOAB range of mesh element entities

Definition at line 729 of file TempestRemapper.hpp.

{
    switch( ctx )
    {
        case Remapper::SourceMesh:
            return m_source_entities;
        case Remapper::TargetMesh:
            return m_target_entities;
        case Remapper::OverlapMesh:
            return m_overlap_entities;
        case Remapper::CoveringMesh:
            return m_covering_source_entities;
        case Remapper::DEFAULT:
        default:
            MB_SET_ERR_RET_VAL( "Invalid context passed to GetMeshSet", m_overlap_entities );
    }
}

References moab::Remapper::CoveringMesh, moab::Remapper::DEFAULT, m_covering_source_entities, m_overlap_entities, m_source_entities, m_target_entities, MB_SET_ERR_RET_VAL, moab::Remapper::OverlapMesh, moab::Remapper::SourceMesh, and moab::Remapper::TargetMesh.

GetMeshSet() [1/2]

moab::EntityHandle & moab::TempestRemapper::GetMeshSet ( Remapper::IntersectionContext  ctx )

inline

Get the MOAB mesh set corresponding to the intersection context.

Parameters

ctx	Intersection context

Returns

MOAB mesh set handle

Definition at line 675 of file TempestRemapper.hpp.

{
    switch( ctx )
    {
        case Remapper::SourceMesh:
            return m_source_set;
        case Remapper::TargetMesh:
            return m_target_set;
        case Remapper::OverlapMesh:
            return m_overlap_set;
        case Remapper::CoveringMesh:
            return m_covering_source_set;
        case Remapper::DEFAULT:
        default:
            MB_SET_ERR_RET_VAL( "Invalid context passed to GetMeshSet", m_overlap_set );
    }
}

References moab::Remapper::CoveringMesh, moab::Remapper::DEFAULT, m_covering_source_set, m_overlap_set, m_source_set, m_target_set, MB_SET_ERR_RET_VAL, moab::Remapper::OverlapMesh, moab::Remapper::SourceMesh, and moab::Remapper::TargetMesh.

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

GetMeshSet() [2/2]

moab::EntityHandle moab::TempestRemapper::GetMeshSet ( Remapper::IntersectionContext  ctx ) const

inline

Const overload. Get the MOAB mesh set corresponding to the intersection context.

Parameters

ctx	Intersection context

Returns

MOAB mesh set handle

Definition at line 693 of file TempestRemapper.hpp.

{
    switch( ctx )
    {
        case Remapper::SourceMesh:
            return m_source_set;
        case Remapper::TargetMesh:
            return m_target_set;
        case Remapper::OverlapMesh:
            return m_overlap_set;
        case Remapper::CoveringMesh:
            return m_covering_source_set;
        case Remapper::DEFAULT:
        default:
            MB_SET_ERR_RET_VAL( "Invalid context passed to GetMeshSet", m_overlap_set );
    }
}

References moab::Remapper::CoveringMesh, moab::Remapper::DEFAULT, m_covering_source_set, m_overlap_set, m_source_set, m_target_set, MB_SET_ERR_RET_VAL, moab::Remapper::OverlapMesh, moab::Remapper::SourceMesh, and moab::Remapper::TargetMesh.

GetMeshType()

TempestRemapper::TempestMeshType moab::TempestRemapper::GetMeshType ( Remapper::IntersectionContext  ctx ) const

inline

Get the mesh type corresponding to the intersection context.

Parameters

ctx	Intersection context

Returns

Mesh type

Definition at line 818 of file TempestRemapper.hpp.

{
    switch( ctx )
    {
        case Remapper::SourceMesh:
            return m_source_type;
        case Remapper::TargetMesh:
            return m_target_type;
        case Remapper::OverlapMesh:
            return m_overlap_type;
        case Remapper::DEFAULT:
        default:
            return TempestRemapper::DEFAULT;
    }
}

References moab::Remapper::DEFAULT, DEFAULT, m_overlap_type, m_source_type, m_target_type, moab::Remapper::OverlapMesh, moab::Remapper::SourceMesh, and moab::Remapper::TargetMesh.

GetMeshVertices() [1/2]

moab::Range & moab::TempestRemapper::GetMeshVertices ( Remapper::IntersectionContext  ctx )

inline

Get the mesh vertices corresponding to the intersection context. Useful for point-cloud meshes.

Parameters

ctx	Intersection context

Returns

MOAB range of mesh vertices

Definition at line 747 of file TempestRemapper.hpp.

{
    switch( ctx )
    {
        case Remapper::SourceMesh:
            return m_source_vertices;
        case Remapper::TargetMesh:
            return m_target_vertices;
        case Remapper::CoveringMesh:
            return m_covering_source_vertices;
        case Remapper::DEFAULT:
        default:
            MB_SET_ERR_RET_VAL( "Invalid context passed to GetMeshSet", m_source_vertices );
    }
}

References moab::Remapper::CoveringMesh, moab::Remapper::DEFAULT, m_covering_source_vertices, m_source_vertices, m_target_vertices, MB_SET_ERR_RET_VAL, moab::Remapper::SourceMesh, and moab::Remapper::TargetMesh.

Referenced by main().

GetMeshVertices() [2/2]

const moab::Range & moab::TempestRemapper::GetMeshVertices ( Remapper::IntersectionContext  ctx ) const

inline

Const overload. Get the mesh vertices corresponding to the intersection context. Useful for point-cloud meshes.

Parameters

ctx	Intersection context

Returns

MOAB range of mesh vertices

Definition at line 763 of file TempestRemapper.hpp.

{
    switch( ctx )
    {
        case Remapper::SourceMesh:
            return m_source_vertices;
        case Remapper::TargetMesh:
            return m_target_vertices;
        case Remapper::CoveringMesh:
            return m_covering_source_vertices;
        case Remapper::DEFAULT:
        default:
            MB_SET_ERR_RET_VAL( "Invalid context passed to GetMeshSet", m_source_vertices );
    }
}

References moab::Remapper::CoveringMesh, moab::Remapper::DEFAULT, m_covering_source_vertices, m_source_vertices, m_target_vertices, MB_SET_ERR_RET_VAL, moab::Remapper::SourceMesh, and moab::Remapper::TargetMesh.

GetOverlapAugmentedEntities()

moab::ErrorCode moab::TempestRemapper::GetOverlapAugmentedEntities

(

moab::Range &

sharedGhostEntities

)

Get all the ghosted overlap entities that were accumulated to enable conservation in parallel.

Parameters

sharedGhostEntities

MOAB range of ghosted overlap entities

Returns

ErrorCode indicating the status of the get operation

Definition at line 760 of file TempestRemapper.cpp.

{
    sharedGhostEntities.clear();
#ifdef MOAB_HAVE_MPI
 
    // Remove entities in the intersection mesh that are part of the ghosted overlap
    if( is_parallel )
    {
        moab::Range allents;
        MB_CHK_SET_ERR( m_interface->get_entities_by_dimension( m_overlap_set, 2, allents ),
                        "Getting entities dim 2 failed" );
 
        moab::Range sharedents;
        moab::Tag ghostTag;
        std::vector< int > ghFlags( allents.size() );
        MB_CHK_ERR( m_interface->tag_get_handle( "ORIG_PROC", ghostTag ) );
        MB_CHK_ERR( m_interface->tag_get_data( ghostTag, allents, &ghFlags[0] ) );
        for( unsigned i = 0; i < allents.size(); ++i )
            if( ghFlags[i] >= 0 )                 // it means it is a ghost overlap element
                sharedents.insert( allents[i] );  // this should not participate in smat!
 
        allents = subtract( allents, sharedents );
 
        // Get connectivity from all ghosted elements and filter out
        // the vertices that are not owned
        moab::Range ownedverts, sharedverts;
        MB_CHK_SET_ERR( m_interface->get_connectivity( allents, ownedverts ), "Deleting entities dim 0 failed" );
        MB_CHK_SET_ERR( m_interface->get_connectivity( sharedents, sharedverts ), "Deleting entities dim 0 failed" );
        sharedverts = subtract( sharedverts, ownedverts );
        // MB_CHK_SET_ERR( m_interface->remove_entities(m_overlap_set, sharedents), // "Deleting entities dim 2 failed" ); MB_CHK_SET_ERR( m_interface->remove_entities(m_overlap_set,
        // sharedverts), "Deleting entities dim 0 failed" );
 
        sharedGhostEntities.merge( sharedents );
        // sharedGhostEntities.merge(sharedverts);
    }
#endif
    return moab::MB_SUCCESS;
}

References moab::Range::clear(), moab::Range::insert(), MB_CHK_ERR, MB_CHK_SET_ERR, MB_SUCCESS, moab::Range::merge(), moab::Range::size(), and moab::subtract().

Referenced by main().

initialize()

ErrorCode moab::TempestRemapper::initialize ( bool  initialize_fsets = true )

virtual

Initialize the TempestRemapper object internal data structures including the mesh sets and TempestRemap mesh references.

Parameters

initialize_fsets

Flag to initialize the mesh sets (default: true)

Returns

ErrorCode indicating the status of the initialization

Definition at line 54 of file TempestRemapper.cpp.

{
    if( initialize_fsets )
    {
        MB_CHK_SET_ERR( m_interface->create_meshset( moab::MESHSET_SET, m_source_set ), "Can't create new set" );
        MB_CHK_SET_ERR( m_interface->create_meshset( moab::MESHSET_SET, m_target_set ), "Can't create new set" );
        MB_CHK_SET_ERR( m_interface->create_meshset( moab::MESHSET_SET, m_overlap_set ), "Can't create new set" );
    }
    else
    {
        m_source_set  = 0;
        m_target_set  = 0;
        m_overlap_set = 0;
    }
 
    is_parallel = false;
    is_root     = true;
    rank        = 0;
    size        = 1;
#ifdef MOAB_HAVE_MPI
    int flagInit;
    MPI_Initialized( &flagInit );
    if( flagInit )
    {
        assert( m_pcomm != nullptr );
        rank        = m_pcomm->rank();
        size        = m_pcomm->size();
        is_root     = ( rank == 0 );
        is_parallel = ( size > 1 );
        // is_parallel = true;
    }
    AnnounceOnlyOutputOnRankZero();
#endif
 
    m_source          = nullptr;
    m_target          = nullptr;
    m_overlap         = nullptr;
    m_covering_source = nullptr;
 
    point_cloud_source = false;
    point_cloud_target = false;
 
    return MB_SUCCESS;
}

References moab::Interface::create_meshset(), is_parallel, is_root, m_covering_source, moab::Remapper::m_interface, m_overlap, m_overlap_set, m_source, m_source_set, m_target, m_target_set, MB_CHK_SET_ERR, MB_SUCCESS, MESHSET_SET, point_cloud_source, point_cloud_target, rank, and size.

Referenced by main().

IsRegionalMesh()

bool moab::TempestRemapper::IsRegionalMesh ( ) const

inline

Whether the meshes have been declared regionally refined; see SetRegionalMesh().

Definition at line 200 of file TempestRemapper.hpp.

    {
        return rrmgrids;
    }

References rrmgrids.

ResetMeshSet()

void moab::TempestRemapper::ResetMeshSet ( Remapper::IntersectionContext  ctx, moab::EntityHandle  meshSet  )

inline

Reconstruct mesh, used now only for IO; need a better solution maybe.

Parameters

ctx	Intersection context
meshSet	MOAB mesh set handle

Definition at line 649 of file TempestRemapper.hpp.

{
    switch( ctx )
    {
        case Remapper::SourceMesh:
            delete m_source;
            m_source     = new Mesh;
            m_source_set = meshSet;
            convert_mesh_to_tempest_private( m_source, m_source_set, m_source_entities, &m_source_vertices );
            m_source->CalculateFaceAreas( false );  // fInputConcave is false ?
            break;
        case Remapper::TargetMesh:
            // not needed yet
            break;
        case Remapper::OverlapMesh:
            // not needed yet
            break;
        case Remapper::CoveringMesh:
            // not needed yet
            break;
        case Remapper::DEFAULT:
        default:
            break;
    }
}

References convert_mesh_to_tempest_private(), moab::Remapper::CoveringMesh, moab::Remapper::DEFAULT, m_source, m_source_entities, m_source_set, m_source_vertices, moab::Remapper::OverlapMesh, moab::Remapper::SourceMesh, and moab::Remapper::TargetMesh.

SetAreaMethod()

void moab::TempestRemapper::SetAreaMethod ( IntxAreaUtils::AreaMethod  method )

inline

Validate the GLOBAL_ID tags on the source and target meshes.

The remapping machinery identifies entities across MPI ranks solely by their GLOBAL_ID: the coverage migration packs vertex ids into tuple lists and resolves them on the receiving rank, and the map writer indexes rows/columns by element id. A missing tag reads back as the dense-tag default of -1 (see Core::globalId_tag), which is silently accepted and produces collapsed cells or a corrupt map far from the actual cause.

This checks, collectively, that every vertex and every element of both meshes has a strictly positive id, and that ids are locally unique. It is intended to run before any expensive operation so that a bad mesh fails immediately with a descriptive message.

Parameters

throw_error

If true (default) return MB_FAILURE on the first problem found; if false only report the diagnosis and continue.

Returns

ErrorCode MB_SUCCESS when both meshes carry valid ids

Select the formula used for all spherical area computations driven by this remapper: the intersection kernel, the covering-set construction and the overlap-orientation fixups.

Offline drivers (mbtempest) should call this so that a single choice applies uniformly; online users get IntxAreaUtils::DEFAULT_AREA_METHOD, which is the adaptive Van Oosterom-Strackee formula.

Must be called before ConstructCoveringSet()/ComputeOverlapMesh() to take effect.

Definition at line 170 of file TempestRemapper.hpp.

    {
        m_area_method = method;
    }

References m_area_method.

Referenced by main().

SetMesh()

void moab::TempestRemapper::SetMesh ( Remapper::IntersectionContext  ctx, Mesh *  mesh, bool  overwrite = true  )

inline

Set the TempestRemap mesh object according to the intersection context.

Parameters

ctx	Intersection context
mesh	Pointer to the TempestRemap mesh object
overwrite	Flag to overwrite the existing mesh (default: true)

Definition at line 619 of file TempestRemapper.hpp.

{
    switch( ctx )
    {
        case Remapper::SourceMesh:
            if( !overwrite && m_source ) return;
            if( overwrite && m_source ) delete m_source;
            m_source = mesh;
            break;
        case Remapper::TargetMesh:
            if( !overwrite && m_target ) return;
            if( overwrite && m_target ) delete m_target;
            m_target = mesh;
            break;
        case Remapper::OverlapMesh:
            if( !overwrite && m_overlap ) return;
            if( overwrite && m_overlap ) delete m_overlap;
            m_overlap = mesh;
            break;
        case Remapper::CoveringMesh:
            if( !overwrite && m_covering_source ) return;
            if( overwrite && m_covering_source ) delete m_covering_source;
            m_covering_source = mesh;
            break;
        case Remapper::DEFAULT:
        default:
            break;
    }
}

References moab::Remapper::CoveringMesh, moab::Remapper::DEFAULT, m_covering_source, m_overlap, m_source, m_target, moab::Remapper::OverlapMesh, moab::Remapper::SourceMesh, and moab::Remapper::TargetMesh.

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

SetMeshSet()

void moab::TempestRemapper::SetMeshSet	(	Remapper::IntersectionContext	ctx,
		moab::EntityHandle	mset,
		moab::Range *	entities = nullptr
	)

Set the mesh set according to the intersection context.

Parameters

ctx	Intersection context
mset	MOAB mesh set handle
entities	MOAB range of entities (optional)

Definition at line 1008 of file TempestRemapper.cpp.

{
 
    if( ctx == Remapper::SourceMesh )  // should not be used
    {
        m_source_set = mset;
        if( entities ) m_source_entities = *entities;
    }
    else if( ctx == Remapper::TargetMesh )
    {
        m_target_set = mset;
        if( entities ) m_target_entities = *entities;
    }
    else if( ctx == Remapper::CoveringMesh )
    {
        m_covering_source_set = mset;
        if( entities ) m_covering_source_entities = *entities;
    }
    else
    {
        // nothing to do really..
        return;
    }
}

References moab::Remapper::CoveringMesh, m_covering_source_entities, m_covering_source_set, m_source_entities, m_source_set, m_target_entities, m_target_set, moab::Remapper::SourceMesh, and moab::Remapper::TargetMesh.

SetMeshType()

void moab::TempestRemapper::SetMeshType ( Remapper::IntersectionContext  ctx, const std::vector< int > &  metadata  )

inline

Set the mesh type corresponding to the intersection context.

Parameters

ctx	Intersection context
metadata	Vector of mesh type metadata

Definition at line 779 of file TempestRemapper.hpp.

{
    switch( ctx )
    {
        case Remapper::SourceMesh:
            m_source_type = static_cast< moab::TempestRemapper::TempestMeshType >( metadata[0] );
            if( metadata[0] == 1 )  // RLL mesh
            {
                m_source_metadata.resize( 2 );
                m_source_metadata[0] = metadata[1];
                m_source_metadata[1] = metadata[2];
            }
            else
            {
                m_source_metadata.resize( 1 );
                m_source_metadata[0] = metadata[1];
            }
            break;
        case Remapper::TargetMesh:
            m_target_type = static_cast< moab::TempestRemapper::TempestMeshType >( metadata[0] );
            if( metadata[0] == 1 )  // RLL mesh
            {
                m_target_metadata.resize( 2 );
                m_target_metadata[0] = metadata[1];
                m_target_metadata[1] = metadata[2];
            }
            else
            {
                m_target_metadata.resize( 1 );
                m_target_metadata[0] = metadata[1];
            }
            break;
        case Remapper::OverlapMesh:
            m_overlap_type = moab::TempestRemapper::OVERLAP_FILES;
        default:
            break;
    }
}

References m_overlap_type, m_source_metadata, m_source_type, m_target_metadata, m_target_type, OVERLAP_FILES, moab::Remapper::OverlapMesh, moab::Remapper::SourceMesh, and moab::Remapper::TargetMesh.

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

SetRegionalMesh()

void moab::TempestRemapper::SetRegionalMesh ( bool  regional )

inline

Declare that the source and/or target mesh is regionally refined, so their domains need not coincide.

With this set, a source or target cell may be only partially covered by the other mesh (or not covered at all). The overlap-based area correction then treats the accumulated overlap area as authoritative for partially covered cells, rather than requiring it to agree with the geometric area to 1e-10. Without it a partially covered cell keeps its full geometric area while receiving only part of the overlap, which drives its map row sum below one.

Must be set before GenerateRemappingWeights() to take effect.

Definition at line 194 of file TempestRemapper.hpp.

    {
        rrmgrids = regional;
    }

References rrmgrids.

Referenced by main().

validate_global_ids_private()

ErrorCode moab::TempestRemapper::validate_global_ids_private ( moab::EntityHandle  mesh_set, int  dimension, const char *  mesh_name, std::string &  error_message  )

private

Helper for ValidateGlobalIds: check one mesh set at one dimension.

Definition at line 1250 of file TempestRemapper.cpp.

{
    Range ents;
    MB_CHK_ERR( m_interface->get_entities_by_dimension( mesh_set, dimension, ents ) );
    if( ents.empty() ) return MB_SUCCESS;  // nothing to check (e.g. empty partition)
 
    const char* what = ( 0 == dimension ? "vertex" : "element" );
 
    std::vector< int > gids( ents.size(), -1 );
    MB_CHK_ERR( m_interface->tag_get_data( m_interface->globalId_tag(), ents, gids.data() ) );
 
    // 1) every id must be strictly positive.  A missing tag reads back as the
    //    dense default of -1, which is the common failure mode.
    size_t n_bad = 0;
    int first_bad = 0;
    for( size_t i = 0; i < gids.size(); ++i )
        if( gids[i] <= 0 )
        {
            if( !n_bad ) first_bad = gids[i];
            ++n_bad;
        }
 
    if( n_bad )
    {
        std::ostringstream os;
        os << mesh_name << " mesh has " << n_bad << " of " << ents.size() << " " << what
           << " entities with a non-positive GLOBAL_ID (first bad value = " << first_bad << ")";
        if( n_bad == ents.size() )
            os << "; the GLOBAL_ID tag is most likely absent, so every entry is the tag default";
        error_message = os.str();
        return MB_FAILURE;
    }
 
    // 2) ids must be locally unique.  Duplicates make entity identification
    //    ambiguous during migration and corrupt the map rows/columns.
    std::vector< int > sorted( gids );
    std::sort( sorted.begin(), sorted.end() );
    std::vector< int >::iterator dup = std::adjacent_find( sorted.begin(), sorted.end() );
    if( dup != sorted.end() )
    {
        const size_t n_unique = std::distance( sorted.begin(), std::unique( sorted.begin(), sorted.end() ) );
        std::ostringstream os;
        os << mesh_name << " mesh has duplicate " << what << " GLOBAL_IDs: " << ents.size() << " entities but only "
           << n_unique << " distinct ids (e.g. id " << *dup << " appears more than once)";
        error_message = os.str();
        return MB_FAILURE;
    }
 
    return MB_SUCCESS;
}

References moab::Range::empty(), moab::Interface::get_entities_by_dimension(), moab::Interface::globalId_tag(), moab::Remapper::m_interface, MB_CHK_ERR, MB_SUCCESS, moab::Range::size(), and moab::Interface::tag_get_data().

Referenced by ValidateGlobalIds().

ValidateGlobalIds()

ErrorCode moab::TempestRemapper::ValidateGlobalIds

(

bool

throw_error = true

)

Definition at line 1304 of file TempestRemapper.cpp.

{
    // Element ids are always required: they become the rows and columns of the map.
    //
    // Vertex ids are only required in parallel, where construct_covering_set() keys on
    // them to identify the corners of migrated source cells -- unnumbered vertices
    // collapse every corner to one handle and produce degenerate cells.  Nothing
    // migrates in serial, so the vertex ids are never consulted and demanding them
    // rejects meshes that work perfectly well: in-memory NetCDF domain meshes, for
    // instance, carry element ids but no vertex ids.
    const bool check_vertices = is_parallel;
 
    const EntityHandle sets[2] = { m_source_set, m_target_set };
    const char* names[2]       = { "source", "target" };
 
    std::string message;
    int local_bad = 0;
    for( int im = 0; im < 2 && !local_bad; ++im )
    {
        if( !sets[im] ) continue;
        for( int dim = ( check_vertices ? 0 : 2 ); dim <= 2; dim += 2 )  // vertices (0) and faces (2)
        {
            if( MB_SUCCESS != validate_global_ids_private( sets[im], dim, names[im], message ) )
            {
                local_bad = 1;
                break;
            }
        }
    }
 
    int global_bad = local_bad;
#ifdef MOAB_HAVE_MPI
    if( m_pcomm )
    {
        // Collective: a mesh is only valid if it is valid on every rank, and every
        // rank must agree so that they fail (or continue) together.
        MPI_Allreduce( &local_bad, &global_bad, 1, MPI_INT, MPI_MAX, m_pcomm->comm() );
    }
#endif
 
    if( global_bad )
    {
        if( local_bad )
            std::cout << "[ERROR] rank " << rank << ": " << message << std::endl;
        else if( is_root )
            std::cout << "[ERROR] invalid GLOBAL_IDs detected on another rank" << std::endl;
 
        if( throw_error )
            MB_SET_ERR( MB_FAILURE, "Invalid GLOBAL_ID tags on input meshes; refusing to proceed. "
                                    "Ensure both meshes carry unique, strictly positive GLOBAL_IDs on "
                                    "vertices and elements (e.g. re-partition with 'mbpart -j', or read "
                                    "SCRIP/NetCDF sources in parallel so ids are assigned)." );
        return MB_FAILURE;
    }
 
    return MB_SUCCESS;
}

References is_parallel, is_root, m_source_set, m_target_set, MB_SET_ERR, MB_SUCCESS, rank, and validate_global_ids_private().

Referenced by ConstructCoveringSet().

WriteTempestIntersectionMesh()

moab::ErrorCode moab::TempestRemapper::WriteTempestIntersectionMesh	(	std::string	strOutputFileName,
		const bool	fAllParallel,
		const bool	fInputConcave,
		const bool	fOutputConcave
	)

Gather the overlap mesh and associated source/target data and write it out to disk using the TempestRemap output interface. This information can then be used with the "GenerateOfflineMap" tool in TempestRemap as needed.

Parameters

strOutputFileName	Output file name
fAllParallel	Flag to write all parallel data (default: false)
fInputConcave	Flag to indicate if the input mesh is concave (default: false)
fOutputConcave	Flag to indicate if the output mesh is concave (default: false)

Returns

ErrorCode indicating the status of the write operation

Definition at line 968 of file TempestRemapper.cpp.

{
 
    // Let us alos write out the TempestRemap equivalent so that we can do some verification checks
    if( fAllParallel )
    {
        if( is_root && size == 1 )
        {
            this->m_source->CalculateFaceAreas( fInputConcave );
            this->m_target->CalculateFaceAreas( fOutputConcave );
        }
        else
        {
            // Perform reduction and write from root processor
            this->m_source->CalculateFaceAreas( fInputConcave );
            this->m_covering_source->CalculateFaceAreas( fInputConcave );
            this->m_target->CalculateFaceAreas( fOutputConcave );
        }
    }
    else
    {
        this->m_source->CalculateFaceAreas( fInputConcave );
        this->m_target->CalculateFaceAreas( fOutputConcave );
    }
 
    // The overlap mesh is written by TempestRemap's own NetCDF writer (Mesh::Write). This is
    // forwarded to libTempestRemap and cannot go through the MBNcDispatch layer; guard it in
    // one place and skip with a notice when NetCDF is unavailable.
#ifdef MOAB_HAVE_NETCDF
    this->m_overlap->Write( strOutputFileName.c_str(), NcFile::Netcdf4 );
#else
    if( is_root ) std::cout << "NetCDF is not configured. Intersection mesh write will be skipped...\n";
#endif
 
    return moab::MB_SUCCESS;
}

References MB_SUCCESS.

Friends And Related Function Documentation

TempestOnlineMap

friend class TempestOnlineMap

friend

Definition at line 76 of file TempestRemapper.hpp.

Member Data Documentation

constructEdgeMap

bool moab::TempestRemapper::constructEdgeMap

Flag to construct the edge map within the TempestRemap data structures.

If set to true, the edge map will be constructed within the TempestRemap data structures.

Definition at line 471 of file TempestRemapper.hpp.

Referenced by convert_mesh_to_tempest_private(), and main().

is_parallel

bool moab::TempestRemapper::is_parallel = false

private

Definition at line 594 of file TempestRemapper.hpp.

Referenced by ComputeOverlapMesh(), ConstructCoveringSet(), ConvertOverlapMeshSourceOrdered(), initialize(), moab::TempestOnlineMap::TempestOnlineMap(), and ValidateGlobalIds().

is_root

bool moab::TempestRemapper::is_root = false

private

Definition at line 595 of file TempestRemapper.hpp.

Referenced by convert_tempest_mesh_private(), ConvertMeshToTempest(), ConvertTempestMesh(), initialize(), moab::TempestOnlineMap::TempestOnlineMap(), and ValidateGlobalIds().

m_area_method

IntxAreaUtils::AreaMethod moab::TempestRemapper::m_area_method = IntxAreaUtils::DEFAULT_AREA_METHOD

private

Definition at line 591 of file TempestRemapper.hpp.

Referenced by ComputeOverlapMesh(), ConstructCoveringSet(), GetAreaMethod(), and SetAreaMethod().

m_covering_source

Mesh* moab::TempestRemapper::m_covering_source = nullptr

private

Definition at line 586 of file TempestRemapper.hpp.

Referenced by clear(), ComputeOverlapMesh(), ConstructCoveringSet(), ConvertAllMeshesToTempest(), ConvertMeshToTempest(), GetCoveringMesh(), GetMesh(), initialize(), and SetMesh().

m_covering_source_entities

moab::Range moab::TempestRemapper::m_covering_source_entities

private

Definition at line 588 of file TempestRemapper.hpp.

Referenced by clear(), ConstructCoveringSet(), ConvertMeshToTempest(), ConvertOverlapMeshSourceOrdered(), GetMeshEntities(), and SetMeshSet().

m_covering_source_set

moab::EntityHandle moab::TempestRemapper::m_covering_source_set = 0

private

Definition at line 587 of file TempestRemapper.hpp.

Referenced by ComputeOverlapMesh(), ConstructCoveringSet(), ConvertMeshToTempest(), GetCoveringSet(), GetMeshSet(), and SetMeshSet().

m_covering_source_vertices

moab::Range moab::TempestRemapper::m_covering_source_vertices

private

Definition at line 589 of file TempestRemapper.hpp.

Referenced by clear(), ConstructCoveringSet(), ConvertMeshToTempest(), and GetMeshVertices().

m_overlap

Mesh* moab::TempestRemapper::m_overlap = nullptr

private

Definition at line 576 of file TempestRemapper.hpp.

Referenced by clear(), ComputeOverlapMesh(), ConvertMeshToTempest(), ConvertOverlapMeshSourceOrdered(), ConvertTempestMesh(), GetMesh(), initialize(), and SetMesh().

m_overlap_entities

moab::Range moab::TempestRemapper::m_overlap_entities

private

Definition at line 578 of file TempestRemapper.hpp.

Referenced by clear(), ConvertOverlapMeshSourceOrdered(), ConvertTempestMesh(), and GetMeshEntities().

m_overlap_set

moab::EntityHandle moab::TempestRemapper::m_overlap_set = 0

private

Definition at line 579 of file TempestRemapper.hpp.

Referenced by ComputeOverlapMesh(), ConvertOverlapMeshSourceOrdered(), ConvertTempestMesh(), GetMeshSet(), and initialize().

m_overlap_type

TempestMeshType moab::TempestRemapper::m_overlap_type = DEFAULT

private

Definition at line 577 of file TempestRemapper.hpp.

Referenced by ConvertTempestMesh(), GetMeshType(), and SetMeshType().

m_sorted_overlap_order

std::vector< std::pair< int, int > > moab::TempestRemapper::m_sorted_overlap_order

private

Definition at line 580 of file TempestRemapper.hpp.

m_source

Mesh* moab::TempestRemapper::m_source = nullptr

private

Definition at line 556 of file TempestRemapper.hpp.

Referenced by clear(), ConstructCoveringSet(), ConvertAllMeshesToTempest(), ConvertMeshToTempest(), ConvertTempestMesh(), GetMesh(), initialize(), ResetMeshSet(), and SetMesh().

m_source_entities

moab::Range moab::TempestRemapper::m_source_entities

private

Definition at line 558 of file TempestRemapper.hpp.

Referenced by clear(), ConstructCoveringSet(), ConvertMeshToTempest(), ConvertTempestMesh(), GetIMasks(), GetMeshEntities(), ResetMeshSet(), and SetMeshSet().

m_source_metadata

std::vector< int > moab::TempestRemapper::m_source_metadata

private

Definition at line 563 of file TempestRemapper.hpp.

Referenced by SetMeshType().

m_source_set

moab::EntityHandle moab::TempestRemapper::m_source_set = 0

private

Definition at line 560 of file TempestRemapper.hpp.

Referenced by ConstructCoveringSet(), ConvertMeshToTempest(), ConvertTempestMesh(), GetMeshSet(), initialize(), ResetMeshSet(), SetMeshSet(), and ValidateGlobalIds().

m_source_type

TempestMeshType moab::TempestRemapper::m_source_type

private

Definition at line 557 of file TempestRemapper.hpp.

Referenced by ConvertTempestMesh(), GetMeshType(), and SetMeshType().

m_source_vertices

moab::Range moab::TempestRemapper::m_source_vertices

private

Definition at line 559 of file TempestRemapper.hpp.

Referenced by clear(), ConstructCoveringSet(), ConvertMeshToTempest(), ConvertTempestMesh(), GetIMasks(), GetMeshVertices(), and ResetMeshSet().

m_target

Mesh* moab::TempestRemapper::m_target = nullptr

private

Definition at line 566 of file TempestRemapper.hpp.

Referenced by clear(), ComputeOverlapMesh(), ConvertAllMeshesToTempest(), ConvertMeshToTempest(), ConvertTempestMesh(), GetMesh(), initialize(), and SetMesh().

m_target_entities

moab::Range moab::TempestRemapper::m_target_entities

private

Definition at line 568 of file TempestRemapper.hpp.

Referenced by clear(), ConvertMeshToTempest(), ConvertOverlapMeshSourceOrdered(), ConvertTempestMesh(), GetIMasks(), GetMeshEntities(), and SetMeshSet().

m_target_metadata

std::vector< int > moab::TempestRemapper::m_target_metadata

private

Definition at line 573 of file TempestRemapper.hpp.

Referenced by SetMeshType().

m_target_set

moab::EntityHandle moab::TempestRemapper::m_target_set = 0

private

Definition at line 570 of file TempestRemapper.hpp.

Referenced by ComputeOverlapMesh(), ConstructCoveringSet(), ConvertMeshToTempest(), ConvertTempestMesh(), GetMeshSet(), initialize(), SetMeshSet(), and ValidateGlobalIds().

m_target_type

TempestMeshType moab::TempestRemapper::m_target_type

private

Definition at line 567 of file TempestRemapper.hpp.

Referenced by ConvertTempestMesh(), GetMeshType(), and SetMeshType().

m_target_vertices

moab::Range moab::TempestRemapper::m_target_vertices

private

Definition at line 569 of file TempestRemapper.hpp.

Referenced by clear(), ConvertMeshToTempest(), ConvertTempestMesh(), GetIMasks(), and GetMeshVertices().

max_source_edges

int moab::TempestRemapper::max_source_edges = 0

private

Definition at line 561 of file TempestRemapper.hpp.

Referenced by ConstructCoveringSet().

max_target_edges

int moab::TempestRemapper::max_target_edges = 0

private

Definition at line 571 of file TempestRemapper.hpp.

Referenced by ConstructCoveringSet().

mbintx

moab::Intx2MeshOnSphere* moab::TempestRemapper::mbintx = nullptr

private

Definition at line 583 of file TempestRemapper.hpp.

Referenced by ComputeOverlapMesh(), and ConstructCoveringSet().

meshValidate

bool moab::TempestRemapper::meshValidate

Flag to enable mesh validation after loading from file.

If set to true, the mesh will be validated after it is loaded from a file.

Definition at line 463 of file TempestRemapper.hpp.

Referenced by main().

offlineWorkflow

const bool moab::TempestRemapper::offlineWorkflow

Flag indicating whether the workflow is in offline mode.

This flag is used to determine the context of the workflow, specifically whether it is running in an offline mode (mbtempest).

Definition at line 456 of file TempestRemapper.hpp.

Referenced by convert_mesh_to_tempest_private(), and ConvertOverlapMeshSourceOrdered().

point_cloud_source

bool moab::TempestRemapper::point_cloud_source = false

private

Definition at line 562 of file TempestRemapper.hpp.

Referenced by clear(), ConvertMeshToTempest(), GetIMasks(), and initialize().

point_cloud_target

bool moab::TempestRemapper::point_cloud_target = false

private

Definition at line 572 of file TempestRemapper.hpp.

Referenced by clear(), ComputeOverlapMesh(), ConvertMeshToTempest(), GetIMasks(), and initialize().

rank

int moab::TempestRemapper::rank = 0

private

Definition at line 596 of file TempestRemapper.hpp.

Referenced by ComputeOverlapMesh(), ConstructCoveringSet(), convert_tempest_mesh_private(), ConvertMeshToTempest(), initialize(), moab::TempestOnlineMap::TempestOnlineMap(), and ValidateGlobalIds().

rrmgrids

bool moab::TempestRemapper::rrmgrids = false

private

Definition at line 593 of file TempestRemapper.hpp.

Referenced by ConstructCoveringSet(), IsRegionalMesh(), and SetRegionalMesh().

size

int moab::TempestRemapper::size = 0

private

Definition at line 597 of file TempestRemapper.hpp.

Referenced by clear(), ComputeOverlapMesh(), initialize(), and moab::TempestOnlineMap::TempestOnlineMap().

verbose

const bool moab::TempestRemapper::verbose = true

static

Global verbosity flag.

This flag controls the verbosity of the output. If set to true, more detailed output will be generated.

Definition at line 479 of file TempestRemapper.hpp.

Referenced by convert_tempest_mesh_private(), ConvertMeshToTempest(), and ConvertTempestMesh().

---

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

• TempestRemapper.hpp
• TempestRemapper.cpp