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	LoadMesh (Remapper::IntersectionContext ctx, std::string inputFilename, TempestMeshType type)
	Load a mesh from disk of given type 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...
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
ErrorCode	ConvertAllMeshesToTempest ()
	Convert all MOAB meshes to TempestRemap format. More...
moab::ErrorCode	ConvertOverlapMeshSourceOrdered ()
	Convert overlap mesh to source-ordered format. More...
moab::ErrorCode	load_tempest_mesh_private (std::string inputFilename, Mesh **tempest_mesh)
	Load a mesh from disk in TempestRemap 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
TempestMeshType	m_source_type
moab::Range	m_source_entities
moab::Range	m_source_vertices
moab::EntityHandle	m_source_set
int	max_source_edges
bool	point_cloud_source
std::vector< int >	m_source_metadata
Mesh *	m_target
TempestMeshType	m_target_type
moab::Range	m_target_entities
moab::Range	m_target_vertices
moab::EntityHandle	m_target_set
int	max_target_edges
bool	point_cloud_target
std::vector< int >	m_target_metadata
Mesh *	m_overlap
TempestMeshType	m_overlap_type
moab::Range	m_overlap_entities
moab::EntityHandle	m_overlap_set
std::vector< std::pair< int, int > >	m_sorted_overlap_order
moab::Intx2MeshOnSphere *	mbintx
Mesh *	m_covering_source
moab::EntityHandle	m_covering_source_set
moab::Range	m_covering_source_entities
moab::Range	m_covering_source_vertices
IntxAreaUtils::AreaMethod	m_area_method
bool	rrmgrids
bool	is_parallel
bool	is_root
int	rank
int	size

Friends
class	TempestOnlineMap

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

Detailed Description

Definition at line 36 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 54 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 43 of file TempestRemapper.hpp.

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

~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 1000 of file TempestRemapper.cpp.

{
    assert( idtag );
 
    ErrorCode rval;
    Range entities;
    rval = m_interface->get_entities_by_dimension( this_set, dimension, entities );MB_CHK_SET_ERR( rval, "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++;
 
    rval = m_interface->tag_set_data( idtag, entities, &gid[0] );MB_CHK_ERR( rval );
 
    return moab::MB_SUCCESS;
}

References entities, ErrorCode, moab::Interface::get_entities_by_dimension(), moab::Remapper::m_interface, MB_CHK_ERR, MB_CHK_SET_ERR, MB_SUCCESS, 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();
    // gid_to_lid_src.clear();
    // gid_to_lid_tgt.clear();
    // gid_to_lid_covsrc.clear();
    // lid_to_gid_src.clear();
    // lid_to_gid_tgt.clear();
    // lid_to_gid_covsrc.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 1360 of file TempestRemapper.cpp.

{
    ErrorCode rval;
    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" );
            rval = mbintx->intersect_meshes_kdtree( m_covering_source_set, m_target_set, m_overlap_set );MB_CHK_SET_ERR( rval, "Can't compute the intersection of meshes on the sphere with brute-force" );
        }
        else
        {
            if( outputEnabled )
                dbgprint.printf( 0, "Computing intersection mesh with the advancing-front propagation algorithm" );
            rval = mbintx->intersect_meshes( m_covering_source_set, m_target_set, m_overlap_set );MB_CHK_SET_ERR( rval, "Can't compute the intersection of meshes on the sphere" );
        }
 
#ifdef MOAB_HAVE_MPI
        if( is_parallel || rrmgrids )
        {
#ifdef VERBOSE
            std::stringstream ffc, fft, ffo;
            ffc << "cover_" << rank << ".h5m";
            fft << "target_" << rank << ".h5m";
            ffo << "intx_" << rank << ".h5m";
            rval = m_interface->write_mesh( ffc.str().c_str(), &m_covering_source_set, 1 );MB_CHK_ERR( rval );
            rval = m_interface->write_mesh( fft.str().c_str(), &m_target_set, 1 );MB_CHK_ERR( rval );
            rval = m_interface->write_mesh( ffo.str().c_str(), &m_overlap_set, 1 );MB_CHK_ERR( rval );
#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;
                rval = m_interface->get_entities_by_dimension( m_covering_source_set, 2, covEnts );MB_CHK_ERR( rval );
 
                std::map< int, int > loc_gid_to_lid_covsrc;
                std::vector< int > gids( covEnts.size(), -1 );
 
                Tag gidtag = m_interface->globalId_tag();
                rval       = m_interface->tag_get_data( gidtag, covEnts, gids.data() );MB_CHK_ERR( rval );
 
                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;
                rval = m_interface->tag_get_handle( "SourceParent", srcParentTag );MB_CHK_ERR( rval );
                rval = m_interface->get_entities_by_dimension( m_overlap_set, 2, intxCells );MB_CHK_ERR( rval );
                for( Range::iterator it = intxCells.begin(); it != intxCells.end(); it++ )
                {
                    EntityHandle intxCell = *it;
                    int srcParent         = -1;
                    rval                  = m_interface->tag_get_data( srcParentTag, &intxCell, 1, &srcParent );MB_CHK_ERR( rval );
 
                    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;
                            rval                     = mb->get_connectivity( eh, conn, num_nodes );MB_CHK_ERR( rval );
                            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;
                    rval = skinner.find_skin( m_covering_source_set, covEnts, false, skin );MB_CHK_SET_ERR( rval, "Unable to find skin" );
                    for( Range::iterator it = skin.begin(); it != skin.end(); ++it )
                    {
                        const EntityHandle* conn = nullptr;
                        int len                  = 0;
                        rval                     = mb->get_connectivity( *it, conn, len, false );MB_CHK_ERR( rval );
                        for( int ie = 0; ie < len; ++ie )
                        {
                            std::vector< EntityHandle > adjacent_entities;
                            rval = adj_fact->get_adjacencies( conn[ie], 2, false, adjacent_entities );MB_CHK_ERR( rval );
                            for( auto ent : adjacent_entities )
                                notNeededCovCells.erase( ent );  // ent is part of the 1-ring neighborhood
                        }
                    }
 
                    rval = m_interface->write_mesh(
                        std::string( "sourcecoveragemesh_p" + std::to_string( rank ) + ".h5m" ).c_str(),
                        &m_covering_source_set, 1 );MB_CHK_ERR( rval );
                }
 
                // remove now from coverage set the cells that are not needed
                // rval = m_interface->remove_entities( m_covering_source_set, notNeededCovCells );MB_CHK_ERR( rval );
 
                // 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;
            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(), ErrorCode, 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_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, rrmgrids, 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 1212 of file TempestRemapper.cpp.

{
    ErrorCode rval;
 
    if (nb_ghost_layers >= 1)
        gnomonic = false;
    rrmgrids = regional_mesh;
    moab::Range local_verts;
 
    // Initialize intersection context
    mbintx = new moab::Intx2MeshOnSphere( m_interface, moab::IntxAreaUtils::GaussQuadrature );
 
    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
    rval = mbintx->FindMaxEdges( m_source_set, m_target_set );MB_CHK_ERR( rval );
 
    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 )
    {
        rval = mbintx->build_processor_euler_boxes( m_target_set, local_verts, gnomonic );MB_CHK_ERR( rval );
 
        rval = m_interface->create_meshset( moab::MESHSET_SET, m_covering_source_set );MB_CHK_SET_ERR( rval, "Can't create new set" );
 
        rval = mbintx->construct_covering_set( m_source_set, m_covering_source_set, gnomonic, nb_ghost_layers );MB_CHK_ERR( rval );
#ifdef MOAB_DBG
        std::stringstream filename;
        filename << "covering" << rank << ".h5m";
        rval = m_interface->write_file( filename.str().c_str(), 0, 0, &m_covering_source_set, 1 );MB_CHK_ERR( rval );
        std::stringstream targetFile;
        targetFile << "target" << rank << ".h5m";
        rval = m_interface->write_file( targetFile.str().c_str(), 0, 0, &m_target_set, 1 );MB_CHK_ERR( rval );
#endif
    }
    else
    {
#endif
        if( rrmgrids )
        {
            rval = m_interface->create_meshset( moab::MESHSET_SET, m_covering_source_set );MB_CHK_SET_ERR( rval, "Can't create new set" );
 
            double tolerance = 1e-6, btolerance = 1e-3;
            moab::AdaptiveKDTree tree( m_interface );
            moab::Range targetVerts;
 
            rval = m_interface->get_connectivity( m_target_entities, targetVerts, true );MB_CHK_ERR( rval );
 
            rval = tree.build_tree( m_source_entities, &m_source_set );MB_CHK_ERR( rval );
 
            for( unsigned ie = 0; ie < targetVerts.size(); ++ie )
            {
                EntityHandle el = targetVerts[ie], leaf;
                double point[3];
 
                // Get the element centroid to be queried
                rval = m_interface->get_coords( &el, 1, point );MB_CHK_ERR( rval );
 
                // Search for the closest source element in the master mesh corresponding
                // to the target element centroid in the slave mesh
                rval = tree.point_search( point, leaf, tolerance, btolerance );MB_CHK_ERR( rval );
 
                if( leaf == 0 )
                {
                    leaf = m_source_set;  // no hint
                }
 
                std::vector< moab::EntityHandle > leaf_elems;
                // We only care about the dimension that the user specified.
                // MOAB partitions are ordered by elements anyway.
                rval = m_interface->get_entities_by_dimension( leaf, 2, leaf_elems );MB_CHK_ERR( rval );
 
                if( !leaf_elems.size() )
                {
                    // std::cout << ie << ": " << " No leaf elements found." << std::endl;
                    continue;
                }
 
                // Now get the master element centroids so that we can compute
                // the minimum distance to the target point
                std::vector< double > centroids( leaf_elems.size() * 3 );
                rval = m_interface->get_coords( &leaf_elems[0], leaf_elems.size(), &centroids[0] );MB_CHK_ERR( rval );
 
                double dist = 1e5;
                int pinelem = -1;
                for( size_t il = 0; il < leaf_elems.size(); ++il )
                {
                    const double* centroid = &centroids[il * 3];
                    const double locdist   = std::pow( point[0] - centroid[0], 2 ) +
                                           std::pow( point[1] - centroid[1], 2 ) +
                                           std::pow( point[2] - centroid[2], 2 );
 
                    if( locdist < dist )
                    {
                        dist    = locdist;
                        pinelem = il;
                        m_covering_source_entities.insert( leaf_elems[il] );
                    }
                }
 
                if( pinelem < 0 )
                {
                    std::cout << ie
                              << ": [Error] - Could not find a minimum distance within the leaf "
                                 "nodes. Dist = "
                              << dist << std::endl;
                }
            }
            // rval = tree.reset_tree();MB_CHK_ERR(rval);
            std::cout << "[INFO] - Total covering source entities = " << m_covering_source_entities.size() << std::endl;
            rval = m_interface->add_entities( m_covering_source_set, m_covering_source_entities );MB_CHK_ERR( rval );
        }
        else
        {
            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 rval;
}

References moab::Interface::add_entities(), moab::AdaptiveKDTree::build_tree(), ConvertAllMeshesToTempest(), moab::Interface::create_meshset(), ErrorCode, moab::Intx2Mesh::FindMaxEdges(), moab::IntxAreaUtils::GaussQuadrature, moab::Interface::get_connectivity(), moab::Interface::get_coords(), moab::Interface::get_entities_by_dimension(), moab::Range::insert(), is_parallel, 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_entities, 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, mbintx, MESHSET_SET, moab::AdaptiveKDTree::point_search(), 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::Range::size(), moab::tolerance, 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 623 of file TempestRemapper.cpp.

{
    ErrorCode rval;
    Range verts;
 
    NodeVector& nodes = mesh->nodes;
    FaceVector& faces = mesh->faces;
 
    elems.clear();
    rval = m_interface->get_entities_by_dimension( mesh_set, 2, elems );MB_CHK_ERR( rval );
 
    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
    rval = m_interface->get_connectivity( elems, verts );MB_CHK_ERR( rval );
    if( verts.size() == 0 )
    {
        rval = m_interface->get_entities_by_dimension( mesh_set, 0, verts );MB_CHK_ERR( rval );
    }
    // 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();
    rval          = m_interface->tag_get_data( gid, elems, &globIds[0] );MB_CHK_ERR( rval );
    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;
        rval = m_interface->get_connectivity( ehandle, connectface, nnodesf );MB_CHK_ERR( rval );
        // 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 );
    rval = m_interface->get_coords( verts, &coordx[0], &coordy[0], &coordz[0] );MB_CHK_ERR( rval );
    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(), ErrorCode, 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 255 of file TempestRemapper.cpp.

{
    ErrorCode rval;
    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;
    rval = m_interface->query_interface( iface );MB_CHK_SET_ERR( rval, "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;
    rval = iface->get_node_coords( 3, nodes.size(), 0, startv, arrays );MB_CHK_SET_ERR( rval, "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 );
    rval = m_interface->add_entities( mesh_set, mbverts );MB_CHK_SET_ERR( rval, "Can't add entities" );
    rval = m_interface->tag_set_data( gidTag, mbverts, &gidsv[0] );MB_CHK_SET_ERR( rval, "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;
        rval           = m_interface->tag_get_handle( "TargetParent", 1, MB_TYPE_INTEGER, tgtParentTag,
                                                      MB_TAG_DENSE | MB_TAG_CREAT, &defaultInt );MB_CHK_SET_ERR( rval, "can't create positive tag" );
 
        rval = m_interface->tag_get_handle( "SourceParent", 1, MB_TYPE_INTEGER, srcParentTag,
                                            MB_TAG_DENSE | MB_TAG_CREAT, &defaultInt );MB_CHK_SET_ERR( rval, "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] );
                    rval = m_interface->create_element( MBTRI, &conn[0], num_v_per_elem, mbcells[ifaces] );MB_CHK_SET_ERR( rval, "Can't get element connectivity" );
                    ntris++;
                    break;
                case 4:
                    // if( outputEnabled )
                    //     dbgprint.printf( 0, "....Block %d: Quadrilateral Elements [%u].\n", iBlock++, nPolys[iType] );
                    rval = m_interface->create_element( MBQUAD, &conn[0], num_v_per_elem, mbcells[ifaces] );MB_CHK_SET_ERR( rval, "Can't get element connectivity" );
                    nquads++;
                    break;
                default:
                    // if( outputEnabled )
                    //     dbgprint.printf( 0, "....Block %d: Polygonal [%u] Elements [%u].\n", iBlock++, iType,
                    //                      nPolys[iType] );
                    rval = m_interface->create_element( MBPOLYGON, &conn[0], num_v_per_elem, mbcells[ifaces] );MB_CHK_SET_ERR( rval, "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 );
 
        rval = m_interface->add_entities( mesh_set, &mbcells[0], mbcells.size() );MB_CHK_SET_ERR( rval, "Could not add entities" );
 
        rval = m_interface->tag_set_data( gidTag, &mbcells[0], mbcells.size(), &gidse[0] );MB_CHK_SET_ERR( rval, "Can't set global_id tag" );
        if( storeParentInfo )
        {
            rval = m_interface->tag_set_data( srcParentTag, &mbcells[0], mbcells.size(), &srcParent[0] );MB_CHK_SET_ERR( rval, "Can't set tag data" );
            rval = m_interface->tag_set_data( tgtParentTag, &mbcells[0], mbcells.size(), &tgtParent[0] );MB_CHK_SET_ERR( rval, "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::Interface::create_element(), dbgprint, entities, ErrorCode, 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 545 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 571 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(), CreateTempestMesh(), 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 783 of file TempestRemapper.cpp.

{
    ErrorCode rval;
 
    m_overlap_entities.clear();
    rval = m_interface->get_entities_by_dimension( m_overlap_set, 2, m_overlap_entities );MB_CHK_ERR( rval );
    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;
        rval = m_interface->tag_get_handle( "SourceParent", srcParentTag );MB_CHK_ERR( rval );
        rval = m_interface->tag_get_handle( "TargetParent", tgtParentTag );MB_CHK_ERR( rval );
        // 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() ) );
 
// #define USE_SORTED_GIDS
#ifdef USE_SORTED_GIDS
        // let us sort the global indices so that we always have a consistent ordering
        std::sort( gids_src.begin(), gids_src.end() );
        std::sort( gids_tgt.begin(), gids_tgt.end() );
 
        auto find_lid = []( std::vector< int >& gids, int gid ) -> int {
            // auto it = std::equal_range( gids.begin(), gids.end(), gid );
            // return ( ( it.first != it.second ) ? std::distance( gids.begin(), it.first ) : -1 );
 
            auto it = std::lower_bound( gids.begin(), gids.end(), gid );
            return ( it != gids.end() ? std::distance( gids.begin(), it ) : -1 );
        };
#else
        auto find_lid = []( std::vector< int >& gids, int gid ) -> int {
            auto it = std::find( gids.begin(), gids.end(), gid );
            return ( it != gids.end() ? std::distance( gids.begin(), it ) : -1 );
        };
#endif
 
        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( gids_src, rbids_src[ix] );
            assert( std::get< 1 >( sorted_overlap_order[ix] ) >= 0 );
            if( is_parallel && ghFlags[ix] >= 0 )     // it means it is a ghost overlap element
                std::get< 2 >( sorted_overlap_order[ix] ) = -1;  // this should not participate in the map!
            else
                std::get< 2 >( sorted_overlap_order[ix] ) = find_lid( gids_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 )
        {
            // int ix = std::get< 0 >( sorted_overlap_order[ie] );  // original index of the element
            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 );
    rval = m_interface->get_coords( verts, &coordx[0], &coordy[0], &coordz[0] );MB_CHK_ERR( rval );
    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();
 
    // m_overlap->RemoveZeroEdges();
    // m_overlap->RemoveCoincidentNodes( false );
 
    // Generate reverse node array and edge map
    // if ( constructEdgeMap ) m_overlap->ConstructEdgeMap(false);
    // m_overlap->ConstructReverseNodeArray();
 
    m_overlap->Validate();
    return MB_SUCCESS;
}

References moab::Range::begin(), moab::Range::clear(), moab::Range::end(), ErrorCode, moab::Interface::get_connectivity(), moab::Interface::get_coords(), moab::Interface::get_entities_by_dimension(), moab::Interface::globalId_tag(), iface, 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, 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 226 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 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 1032 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 1055 of file TempestRemapper.cpp.

{
    moab::ErrorCode rval;
 
    Tag dofTag;
    bool created = false;
    rval         = m_interface->tag_get_handle( dofTagName.c_str(), nP * nP, MB_TYPE_INTEGER, dofTag,
                                                MB_TAG_DENSE | MB_TAG_CREAT, 0, &created );MB_CHK_SET_ERR( rval, "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];
        rval            = m_interface->get_coords( &eh, 1, elcoords );
        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 )
        {
            rval = m_interface->tag_set_data( dofTag, &current_eh, 1, dofIDs );MB_CHK_SET_ERR( rval, "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(), entities, ErrorCode, moab::Interface::get_coords(), moab::Remapper::m_interface, MB_CHK_SET_ERR, MB_INVALID_SIZE, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TYPE_INTEGER, moab::Interface::tag_get_handle(), and moab::Interface::tag_set_data().

Referenced by GenerateCSMeshMetadata(), and main().

GetCoveringMesh()

Mesh * moab::TempestRemapper::GetCoveringMesh ( )

inline

Get the covering mesh (TempestRemap) object.

Returns

Pointer to the covering mesh object

Definition at line 746 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 751 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 2167 of file TempestRemapper.cpp.

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

References moab::Remapper::CoveringMesh, ErrorCode, 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 513 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 CreateTempestMesh(), 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 623 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 641 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 587 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 CreateTempestMesh(), 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 605 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 730 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 659 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 675 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 743 of file TempestRemapper.cpp.

{
    sharedGhostEntities.clear();
#ifdef MOAB_HAVE_MPI
    moab::ErrorCode rval;
 
    // Remove entities in the intersection mesh that are part of the ghosted overlap
    if( is_parallel )
    {
        moab::Range allents;
        rval = m_interface->get_entities_by_dimension( m_overlap_set, 2, allents );MB_CHK_SET_ERR( rval, "Getting entities dim 2 failed" );
 
        moab::Range sharedents;
        moab::Tag ghostTag;
        std::vector< int > ghFlags( allents.size() );
        rval = m_interface->tag_get_handle( "ORIG_PROC", ghostTag );MB_CHK_ERR( rval );
        rval = m_interface->tag_get_data( ghostTag, allents, &ghFlags[0] );MB_CHK_ERR( rval );
        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;
        rval = m_interface->get_connectivity( allents, ownedverts );MB_CHK_SET_ERR( rval, "Deleting entities dim 0 failed" );
        rval = m_interface->get_connectivity( sharedents, sharedverts );MB_CHK_SET_ERR( rval, "Deleting entities dim 0 failed" );
        sharedverts = subtract( sharedverts, ownedverts );
        // rval = m_interface->remove_entities(m_overlap_set, sharedents);MB_CHK_SET_ERR(rval,
        // "Deleting entities dim 2 failed"); rval = m_interface->remove_entities(m_overlap_set,
        // sharedverts);MB_CHK_SET_ERR(rval, "Deleting entities dim 0 failed");
 
        sharedGhostEntities.merge( sharedents );
        // sharedGhostEntities.merge(sharedverts);
    }
#endif
    return moab::MB_SUCCESS;
}

References moab::Range::clear(), ErrorCode, 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 53 of file TempestRemapper.cpp.

{
    ErrorCode rval;
    if( initialize_fsets )
    {
        rval = m_interface->create_meshset( moab::MESHSET_SET, m_source_set );MB_CHK_SET_ERR( rval, "Can't create new set" );
        rval = m_interface->create_meshset( moab::MESHSET_SET, m_target_set );MB_CHK_SET_ERR( rval, "Can't create new set" );
        rval = m_interface->create_meshset( moab::MESHSET_SET, m_overlap_set );MB_CHK_SET_ERR( rval, "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(), ErrorCode, 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().

load_tempest_mesh_private()

ErrorCode moab::TempestRemapper::load_tempest_mesh_private ( std::string  inputFilename, Mesh **  tempest_mesh  )

private

Load a mesh from disk in TempestRemap format.

Parameters

inputFilename	Path to the input mesh file
tempest_mesh	Pointer to store the loaded TempestRemap mesh

Returns

moab::ErrorCode Status of the load operation

Definition at line 177 of file TempestRemapper.cpp.

{
    const bool outputEnabled = ( TempestRemapper::verbose && is_root );
    if( outputEnabled ) std::cout << "\nLoading TempestRemap Mesh object from file = " << inputFilename << " ...\n";
 
    {
        NcError error( NcError::silent_nonfatal );
 
        try
        {
            // Load input mesh
            if( outputEnabled ) std::cout << "Loading mesh ...\n";
            Mesh* mesh = new Mesh( inputFilename );
            mesh->RemoveZeroEdges();
            if( outputEnabled ) std::cout << "----------------\n";
 
            // Validate mesh
            if( meshValidate )
            {
                if( outputEnabled ) std::cout << "Validating mesh ...\n";
                mesh->Validate();
                if( outputEnabled ) std::cout << "-------------------\n";
            }
 
            // Construct the edge map on the mesh
            if( constructEdgeMap )
            {
                if( outputEnabled ) std::cout << "Constructing edge map on mesh ...\n";
                mesh->ConstructEdgeMap( false );
                if( outputEnabled ) std::cout << "---------------------------------\n";
            }
 
            if( tempest_mesh ) *tempest_mesh = mesh;
        }
        catch( Exception& e )
        {
            std::cout << "TempestRemap ERROR: " << e.ToString() << "\n";
            return MB_FAILURE;
        }
        catch( ... )
        {
            return MB_FAILURE;
        }
    }
    return MB_SUCCESS;
}

References constructEdgeMap, moab::error(), is_root, MB_SUCCESS, meshValidate, and verbose.

Referenced by LoadMesh().

LoadMesh()

ErrorCode moab::TempestRemapper::LoadMesh	(	Remapper::IntersectionContext	ctx,
		std::string	inputFilename,
		TempestMeshType	type
	)

Load a mesh from disk of given type and store it under the context specified by the user.

Parameters

ctx	Intersection context
inputFilename	File name of the mesh to load
type	Type of mesh to load

Returns

ErrorCode indicating the status of the mesh loading

Definition at line 152 of file TempestRemapper.cpp.

{
    if( ctx == Remapper::SourceMesh )
    {
        m_source_type = type;
        return load_tempest_mesh_private( inputFilename, &m_source );
    }
    else if( ctx == Remapper::TargetMesh )
    {
        m_target_type = type;
        return load_tempest_mesh_private( inputFilename, &m_target );
    }
    else if( ctx != Remapper::DEFAULT )
    {
        m_overlap_type = type;
        return load_tempest_mesh_private( inputFilename, &m_overlap );
    }
    else
    {
        MB_CHK_SET_ERR( MB_FAILURE, "Invalid IntersectionContext context provided" );
    }
}

References moab::Remapper::DEFAULT, load_tempest_mesh_private(), m_overlap, m_overlap_type, m_source, m_source_type, m_target, m_target_type, MB_CHK_SET_ERR, moab::Remapper::SourceMesh, and moab::Remapper::TargetMesh.

Referenced by CreateTempestMesh(), and main().

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 561 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.

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 531 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 CreateTempestMesh().

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 970 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, entities, 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 691 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 CreateTempestMesh().

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 934 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 );
            this->m_overlap->Write( strOutputFileName.c_str(), NcFile::Netcdf4 );
        }
        else
        {
            // Perform reduction and write from root processor
            // if ( is_root )
            //     std::cout << "--- PARALLEL IMPLEMENTATION is NOT AVAILABLE yet ---\n";
 
            this->m_source->CalculateFaceAreas( fInputConcave );
            this->m_covering_source->CalculateFaceAreas( fInputConcave );
            this->m_target->CalculateFaceAreas( fOutputConcave );
            this->m_overlap->Write( strOutputFileName.c_str(), NcFile::Netcdf4 );
        }
    }
    else
    {
        this->m_source->CalculateFaceAreas( fInputConcave );
        this->m_target->CalculateFaceAreas( fOutputConcave );
        this->m_overlap->Write( strOutputFileName.c_str(), NcFile::Netcdf4 );
    }
 
    return moab::MB_SUCCESS;
}

References MB_SUCCESS, and size.

Friends And Related Function Documentation

TempestOnlineMap

friend class TempestOnlineMap

friend

Definition at line 66 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 382 of file TempestRemapper.hpp.

Referenced by convert_mesh_to_tempest_private(), load_tempest_mesh_private(), and main().

is_parallel

bool moab::TempestRemapper::is_parallel

private

Definition at line 508 of file TempestRemapper.hpp.

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

is_root

bool moab::TempestRemapper::is_root

private

Definition at line 508 of file TempestRemapper.hpp.

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

m_area_method

IntxAreaUtils::AreaMethod moab::TempestRemapper::m_area_method

private

Definition at line 505 of file TempestRemapper.hpp.

m_covering_source

Mesh* moab::TempestRemapper::m_covering_source

private

Definition at line 496 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 498 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

private

Definition at line 497 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 499 of file TempestRemapper.hpp.

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

m_overlap

Mesh* moab::TempestRemapper::m_overlap

private

Definition at line 486 of file TempestRemapper.hpp.

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

m_overlap_entities

moab::Range moab::TempestRemapper::m_overlap_entities

private

Definition at line 488 of file TempestRemapper.hpp.

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

m_overlap_set

moab::EntityHandle moab::TempestRemapper::m_overlap_set

private

Definition at line 489 of file TempestRemapper.hpp.

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

m_overlap_type

TempestMeshType moab::TempestRemapper::m_overlap_type

private

Definition at line 487 of file TempestRemapper.hpp.

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

m_sorted_overlap_order

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

private

Definition at line 490 of file TempestRemapper.hpp.

m_source

Mesh* moab::TempestRemapper::m_source

private

Definition at line 466 of file TempestRemapper.hpp.

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

m_source_entities

moab::Range moab::TempestRemapper::m_source_entities

private

Definition at line 468 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 473 of file TempestRemapper.hpp.

Referenced by SetMeshType().

m_source_set

moab::EntityHandle moab::TempestRemapper::m_source_set

private

Definition at line 470 of file TempestRemapper.hpp.

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

m_source_type

TempestMeshType moab::TempestRemapper::m_source_type

private

Definition at line 467 of file TempestRemapper.hpp.

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

m_source_vertices

moab::Range moab::TempestRemapper::m_source_vertices

private

Definition at line 469 of file TempestRemapper.hpp.

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

m_target

Mesh* moab::TempestRemapper::m_target

private

Definition at line 476 of file TempestRemapper.hpp.

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

m_target_entities

moab::Range moab::TempestRemapper::m_target_entities

private

Definition at line 478 of file TempestRemapper.hpp.

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

m_target_metadata

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

private

Definition at line 483 of file TempestRemapper.hpp.

Referenced by SetMeshType().

m_target_set

moab::EntityHandle moab::TempestRemapper::m_target_set

private

Definition at line 480 of file TempestRemapper.hpp.

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

m_target_type

TempestMeshType moab::TempestRemapper::m_target_type

private

Definition at line 477 of file TempestRemapper.hpp.

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

m_target_vertices

moab::Range moab::TempestRemapper::m_target_vertices

private

Definition at line 479 of file TempestRemapper.hpp.

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

max_source_edges

int moab::TempestRemapper::max_source_edges

private

Definition at line 471 of file TempestRemapper.hpp.

Referenced by ConstructCoveringSet().

max_target_edges

int moab::TempestRemapper::max_target_edges

private

Definition at line 481 of file TempestRemapper.hpp.

Referenced by ConstructCoveringSet().

mbintx

moab::Intx2MeshOnSphere* moab::TempestRemapper::mbintx

private

Definition at line 493 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 374 of file TempestRemapper.hpp.

Referenced by load_tempest_mesh_private(), and 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 367 of file TempestRemapper.hpp.

Referenced by convert_mesh_to_tempest_private().

point_cloud_source

bool moab::TempestRemapper::point_cloud_source

private

Definition at line 472 of file TempestRemapper.hpp.

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

point_cloud_target

bool moab::TempestRemapper::point_cloud_target

private

Definition at line 482 of file TempestRemapper.hpp.

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

rank

int moab::TempestRemapper::rank

private

Definition at line 509 of file TempestRemapper.hpp.

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

rrmgrids

bool moab::TempestRemapper::rrmgrids

private

Definition at line 507 of file TempestRemapper.hpp.

Referenced by ComputeOverlapMesh(), and ConstructCoveringSet().

size

int moab::TempestRemapper::size

private

Definition at line 509 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 390 of file TempestRemapper.hpp.

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

---

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

• TempestRemapper.hpp
• TempestRemapper.cpp