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 , SourceMeshWithGhosts = 4 , TargetMeshWithGhosts = 5 }

Public Member Functions
	TempestRemapper (moab::Interface *mbInt, bool offlineMode=false)
virtual	~TempestRemapper ()
virtual ErrorCode	initialize (bool initialize_fsets=true)
	Initialize the TempestRemapper object internal datastructures 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 order=1)
	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 the intersection mesh only locally without any process communication. More...
moab::ErrorCode	ComputeOverlapMesh (bool kdtree_search=true, bool use_tempest=false, int nLayers=0)
	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)
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...
int	GetGlobalID (Remapper::IntersectionContext ctx, int localID)
	Get the global ID corresponding to the local entity ID according to the context (source, target, intersection) More...
int	GetLocalID (Remapper::IntersectionContext ctx, int globalID)
	Get the local ID corresponding to the global entity ID according to the context (source, target, intersection) More...
moab::ErrorCode	WriteTempestIntersectionMesh (std::string strOutputFileName, const bool fAllParallel, const bool fInputConcave, const bool fOutputConcave)
	Gather the overlap mesh and asssociated 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	ComputeGlobalLocalMaps ()
	Compute the local and global IDs for elements in source/target/coverage meshes. 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
bool	meshValidate
bool	constructEdgeMap

Static Public Attributes
static const bool	verbose = true

Private Member Functions
moab::ErrorCode	convert_overlap_mesh_sorted_by_source ()
moab::ErrorCode	load_tempest_mesh_private (std::string inputFilename, Mesh **tempest_mesh)
moab::ErrorCode	convert_mesh_to_tempest_private (Mesh *mesh, moab::EntityHandle meshset, moab::Range &entities, moab::Range *pverts)
moab::ErrorCode	convert_tempest_mesh_private (TempestMeshType type, Mesh *mesh, moab::EntityHandle &meshset, moab::Range &entities, moab::Range *vertices)
moab::ErrorCode	augment_overlap_set ()

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
std::map< int, int >	gid_to_lid_src
std::map< int, int >	gid_to_lid_covsrc
std::map< int, int >	gid_to_lid_tgt
std::map< int, int >	lid_to_gid_src
std::map< int, int >	lid_to_gid_covsrc
std::map< int, int >	lid_to_gid_tgt
IntxAreaUtils::AreaMethod	m_area_method
moab::EntityHandle	m_source_set_with_ghosts
moab::EntityHandle	m_target_set_with_ghosts
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 102 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

Definition at line 1026 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().

augment_overlap_set()

moab::ErrorCode moab::TempestRemapper::augment_overlap_set ( )

private

Referenced by ComputeOverlapMesh().

clear()

ErrorCode moab::TempestRemapper::clear ( )

virtual

Deallocate and clear any memory initialized in the TempestRemapper object

Definition at line 107 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(), gid_to_lid_covsrc, gid_to_lid_src, gid_to_lid_tgt, lid_to_gid_covsrc, lid_to_gid_src, lid_to_gid_tgt, 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().

ComputeGlobalLocalMaps()

ErrorCode moab::TempestRemapper::ComputeGlobalLocalMaps

(

)

Compute the local and global IDs for elements in source/target/coverage meshes.

Definition at line 872 of file TempestRemapper.cpp.

{
    ErrorCode rval;
 
    if( 0 == m_covering_source )
    {
        m_covering_source = new Mesh();
        rval = convert_mesh_to_tempest_private( m_covering_source, m_covering_source_set, m_covering_source_entities,
                                                &m_covering_source_vertices );MB_CHK_SET_ERR( rval, "Can't convert source Tempest mesh" );
    }
 
#ifdef VERBOSE
    m_covering_source->Write( std::string( "coverage_TR_p" + std::to_string( rank ) + ".g" ) );
    m_target->Write( std::string( "target_TR_p" + std::to_string( rank ) + ".g" ) );
#endif
 
    gid_to_lid_src.clear();
    lid_to_gid_src.clear();
    gid_to_lid_covsrc.clear();
    lid_to_gid_covsrc.clear();
    gid_to_lid_tgt.clear();
    lid_to_gid_tgt.clear();
    {
        Tag gidtag = m_interface->globalId_tag();
 
        std::vector< int > gids;
        if( point_cloud_source )
        {
            gids.resize( m_covering_source_vertices.size(), -1 );
            rval = m_interface->tag_get_data( gidtag, m_covering_source_vertices, &gids[0] );MB_CHK_ERR( rval );
        }
        else
        {
            gids.resize( m_covering_source_entities.size(), -1 );
            rval = m_interface->tag_get_data( gidtag, m_covering_source_entities, &gids[0] );MB_CHK_ERR( rval );
        }
        for( unsigned ie = 0; ie < gids.size(); ++ie )
        {
            gid_to_lid_covsrc[gids[ie]] = ie;
            lid_to_gid_covsrc[ie]       = gids[ie];
        }
 
        if( point_cloud_source )
        {
            gids.resize( m_source_vertices.size(), -1 );
            rval = m_interface->tag_get_data( gidtag, m_source_vertices, &gids[0] );MB_CHK_ERR( rval );
        }
        else
        {
            gids.resize( m_source_entities.size(), -1 );
            rval = m_interface->tag_get_data( gidtag, m_source_entities, &gids[0] );MB_CHK_ERR( rval );
        }
        for( unsigned ie = 0; ie < gids.size(); ++ie )
        {
            gid_to_lid_src[gids[ie]] = ie;
            lid_to_gid_src[ie]       = gids[ie];
        }
 
        if( point_cloud_target )
        {
            gids.resize( m_target_vertices.size(), -1 );
            rval = m_interface->tag_get_data( gidtag, m_target_vertices, &gids[0] );MB_CHK_ERR( rval );
        }
        else
        {
            gids.resize( m_target_entities.size(), -1 );
            rval = m_interface->tag_get_data( gidtag, m_target_entities, &gids[0] );MB_CHK_ERR( rval );
        }
        for( unsigned ie = 0; ie < gids.size(); ++ie )
        {
            gid_to_lid_tgt[gids[ie]] = ie;
            lid_to_gid_tgt[ie]       = gids[ie];
        }
    }
 
    return MB_SUCCESS;
}

References convert_mesh_to_tempest_private(), ErrorCode, gid_to_lid_covsrc, gid_to_lid_src, gid_to_lid_tgt, moab::Interface::globalId_tag(), lid_to_gid_covsrc, lid_to_gid_src, lid_to_gid_tgt, m_covering_source, m_covering_source_entities, m_covering_source_set, m_covering_source_vertices, moab::Remapper::m_interface, m_source_entities, m_source_vertices, m_target, m_target_entities, m_target_vertices, MB_CHK_ERR, MB_CHK_SET_ERR, MB_SUCCESS, point_cloud_source, point_cloud_target, rank, moab::Range::size(), and moab::Interface::tag_get_data().

Referenced by ComputeOverlapMesh().

ComputeOverlapMesh()

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

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.

Definition at line 1379 of file TempestRemapper.cpp.

{
    ErrorCode rval;
    const bool outputEnabled = ( this->rank == 0 );
    moab::DebugOutput dbgprint( std::cout, this->rank, 0 );
    dbgprint.set_prefix( "[ComputeOverlapMesh]: " );
 
    // const double radius = 1.0 /*2.0*acos(-1.0)*/;
    // const double boxeps = 0.1;
    // Create the intersection on the sphere object and set up necessary parameters
 
    // First, split based on whether to use Tempest or MOAB
    // If Tempest
    //   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_source != nullptr );
        assert( m_target != nullptr );
        if( m_overlap != nullptr ) delete m_overlap;
        m_overlap         = new Mesh();
        bool concaveMeshA = false, concaveMeshB = false;
        int err = GenerateOverlapWithMeshes( *m_covering_source, *m_target, *m_overlap, "" /*outFilename*/, "Netcdf4",
                                             "exact", concaveMeshA, concaveMeshB, false );
        if( err )
        {
            MB_CHK_SET_ERR( MB_FAILURE, "TempestRemap: Can't 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]] );
                }
                if( nLayers )
                {
                    if( !intxCov.empty() )
                    {
                        // add to the intxCov range the ghost layers we used for coverage for higher order maps
                        Range extraCovCells;
                        rval =
                            MeshTopoUtil( m_interface ).get_bridge_adjacencies( intxCov, 0, 2, extraCovCells, nLayers );MB_CHK_SET_ERR( rval, "Failed to get bridge adjacencies" );
                        intxCov.merge( extraCovCells );
                    }
                }
 
                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
                    rval = augment_overlap_set();MB_CHK_ERR( rval );
                }
            }
        }
#endif
 
        // Fix any inconsistencies in the overlap mesh
        {
            IntxAreaUtils areaAdaptor;
            rval = IntxUtils::fix_degenerate_quads( m_interface, m_overlap_set );MB_CHK_ERR( rval );
            rval = areaAdaptor.positive_orientation( m_interface, m_overlap_set, 1.0 /*radius*/ );MB_CHK_ERR( rval );
        }
 
        // Now let us re-convert the MOAB mesh back to Tempest representation
        rval = this->ComputeGlobalLocalMaps();MB_CHK_ERR( rval );
 
        rval = this->convert_overlap_mesh_sorted_by_source();MB_CHK_ERR( rval );
 
        // free the memory
        delete mbintx;
    }
 
    return MB_SUCCESS;
}

References augment_overlap_set(), moab::Range::begin(), ComputeGlobalLocalMaps(), convert_overlap_mesh_sorted_by_source(), moab::AEntityFactory::create_vert_elem_adjacencies(), dbgprint, moab::Range::empty(), moab::Range::end(), moab::Range::erase(), ErrorCode, moab::Skinner::find_skin(), moab::IntxUtils::fix_degenerate_quads(), moab::AEntityFactory::get_adjacencies(), moab::MeshTopoUtil::get_bridge_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_source, m_target, m_target_set, mb, MB_CHK_ERR, MB_CHK_SET_ERR, MB_SUCCESS, mbintx, moab::Range::merge(), 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	order = 1
	)

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 the intersection mesh only locally without any process communication.

Definition at line 1238 of file TempestRemapper.cpp.

{
    ErrorCode rval;
 
    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_with_ghosts, m_covering_source_set, gnomonic, order );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
 
    return rval;
}

References moab::Interface::add_entities(), moab::AdaptiveKDTree::build_tree(), 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_set_with_ghosts, 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

Definition at line 585 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 ComputeGlobalLocalMaps(), ConvertMeshToTempest(), and ResetMeshSet().

convert_overlap_mesh_sorted_by_source()

ErrorCode moab::TempestRemapper::convert_overlap_mesh_sorted_by_source ( )

private

Definition at line 745 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 );
 
    // Allocate for the overlap mesh
    if( !m_overlap ) m_overlap = new Mesh();
 
    size_t n_overlap_entitites = m_overlap_entities.size();
 
    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 );
 
        // Overlap mesh: resize the source and target connection arrays
        std::vector< int > rbids_src( n_overlap_entitites ), rbids_tgt( n_overlap_entitites );
        rval = m_interface->tag_get_data( srcParentTag, m_overlap_entities, &rbids_src[0] );MB_CHK_ERR( rval );
        rval = m_interface->tag_get_data( tgtParentTag, m_overlap_entities, &rbids_tgt[0] );MB_CHK_ERR( rval );
        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] ) =
                ( gid_to_lid_covsrc.size() ? gid_to_lid_covsrc[rbids_src[ix]] : rbids_src[ix] - 1 );
            std::get< 2 >( sorted_overlap_order[ix] ) =
                ( gid_to_lid_tgt.size() ? gid_to_lid_tgt[rbids_tgt[ix]] : rbids_tgt[ix] - 1 );
        }
        std::sort( sorted_overlap_order.begin(), sorted_overlap_order.end(), IntPairComparator );
        // sorted_overlap_order[ie].second , ie=0,nOverlap-1 is the order such that overlap elems
        // are ordered by source parent
 
        std::vector< int > ghFlags;
        if( is_parallel && size > 1 )
        {
            Tag ghostTag;
            ghFlags.resize( n_overlap_entitites );
            rval = m_interface->tag_get_handle( "ORIG_PROC", ghostTag );MB_CHK_ERR( rval );
            rval = m_interface->tag_get_data( ghostTag, m_overlap_entities, &ghFlags[0] );MB_CHK_ERR( rval );
        }
        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] );
            if( is_parallel && size > 1 && ghFlags[ix] >= 0 )  // it means it is a ghost overlap element
                m_overlap->vecTargetFaceIx[ie] = -1;           // this should not participate in smat!
            else
                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
    rval = m_interface->get_connectivity( m_overlap_entities, verts );MB_CHK_ERR( rval );
    // std::cout << "Vertices size = " << verts.size() << " , psize = " << verts.psize() << ",
    // compactness = " << verts.compactness() << std::endl;
 
    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;
        rval = m_interface->get_connectivity( ehandle, connectface, nnodesf );MB_CHK_ERR( rval );
 
        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(), gid_to_lid_covsrc, gid_to_lid_tgt, iface, moab::IntPairComparator(), is_parallel, moab::Remapper::m_interface, m_overlap, m_overlap_entities, m_overlap_set, MB_CHK_ERR, MB_SUCCESS, moab::Range::size(), size, moab::Interface::tag_get_data(), and moab::Interface::tag_get_handle().

Referenced by ComputeOverlapMesh(), and ConvertMeshToTempest().

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

Definition at line 256 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().

ConvertMeshToTempest()

ErrorCode moab::TempestRemapper::ConvertMeshToTempest

(

Remapper::IntersectionContext

ctx

)

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

Definition at line 546 of file TempestRemapper.cpp.

{
    ErrorCode rval;
    const bool outputEnabled = ( TempestRemapper::verbose && is_root );
 
    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" );
        rval = convert_mesh_to_tempest_private( m_source, m_source_set, m_source_entities, &m_source_vertices );MB_CHK_SET_ERR( rval, "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::TargetMesh )
    {
        if( !m_target ) m_target = new Mesh();
        if( outputEnabled ) dbgprint.printf( 0, "Converting (target) MOAB to TempestRemap Mesh representation ...\n" );
        rval = convert_mesh_to_tempest_private( m_target, m_target_set, m_target_entities, &m_target_vertices );MB_CHK_SET_ERR( rval, "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" );
        rval = convert_overlap_mesh_sorted_by_source();MB_CHK_SET_ERR( rval, "Can't convert overlap mesh to Tempest" );
    }
    else
    {
        MB_CHK_SET_ERR( MB_FAILURE, "Invalid IntersectionContext context provided" );
    }
 
    return rval;
}

References convert_mesh_to_tempest_private(), convert_overlap_mesh_sorted_by_source(), dbgprint, ErrorCode, is_root, 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, 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 CreateTempestMesh(), and main().

ConvertTempestMesh()

ErrorCode moab::TempestRemapper::ConvertTempestMesh

(

Remapper::IntersectionContext

ctx

)

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

Definition at line 227 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.

Definition at line 1058 of file TempestRemapper.cpp.

{
    Mesh csMesh;
    int err;
    moab::ErrorCode rval;
 
    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
    err = GenerateCSMesh( csMesh, csResolution, "", "NetCDF4" );MB_CHK_SET_ERR( err ? MB_FAILURE : MB_SUCCESS, "Failed to generate CS mesh through TempestRemap" );
 
    rval = this->GenerateMeshMetadata( csMesh, ntot_elements, ents, secondary_ents, dofTagName, nP );MB_CHK_SET_ERR( rval, "Failed in call to GenerateMeshMetadata" );
 
    return moab::MB_SUCCESS;
}

References ErrorCode, 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.

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.

Definition at line 1081 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.

Definition at line 591 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.

Definition at line 596 of file TempestRemapper.hpp.

{
    return m_covering_source_set;
}

References m_covering_source_set.

GetGlobalID()

int moab::TempestRemapper::GetGlobalID ( Remapper::IntersectionContext  ctx, int  localID  )

inline

Get the global ID corresponding to the local entity ID according to the context (source, target, intersection)

Definition at line 601 of file TempestRemapper.hpp.

{
    switch( ctx )
    {
        case Remapper::SourceMesh:
            return lid_to_gid_src[localID];
        case Remapper::TargetMesh:
            return lid_to_gid_tgt[localID];
        case Remapper::CoveringMesh:
            return lid_to_gid_covsrc[localID];
        case Remapper::OverlapMesh:
        case Remapper::SourceMeshWithGhosts:
        case Remapper::DEFAULT:
        default:
            return -1;
    }
}

References moab::Remapper::CoveringMesh, moab::Remapper::DEFAULT, lid_to_gid_covsrc, lid_to_gid_src, lid_to_gid_tgt, moab::Remapper::OverlapMesh, moab::Remapper::SourceMesh, moab::Remapper::SourceMeshWithGhosts, and moab::Remapper::TargetMesh.

GetIMasks()

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

Get the masks that could have been defined.

Definition at line 2196 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.

GetLocalID()

int moab::TempestRemapper::GetLocalID ( Remapper::IntersectionContext  ctx, int  globalID  )

inline

Get the local ID corresponding to the global entity ID according to the context (source, target, intersection)

Definition at line 619 of file TempestRemapper.hpp.

{
    switch( ctx )
    {
        case Remapper::SourceMesh:
            return gid_to_lid_src[globalID];
        case Remapper::TargetMesh:
            return gid_to_lid_tgt[globalID];
        case Remapper::CoveringMesh:
            return gid_to_lid_covsrc[globalID];
        case Remapper::DEFAULT:
        case Remapper::OverlapMesh:
        case Remapper::SourceMeshWithGhosts:
        default:
            return -1;
    }
}

References moab::Remapper::CoveringMesh, moab::Remapper::DEFAULT, gid_to_lid_covsrc, gid_to_lid_src, gid_to_lid_tgt, moab::Remapper::OverlapMesh, moab::Remapper::SourceMesh, moab::Remapper::SourceMeshWithGhosts, and moab::Remapper::TargetMesh.

GetMesh()

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

inline

Get the TempestRemap mesh object according to the intersection context.

Definition at line 349 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:  // Remapper::SourceMeshWithGhosts does not need one
        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.

Definition at line 468 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.

Definition at line 486 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.

Definition at line 424 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::SourceMeshWithGhosts:
            return m_source_set_with_ghosts;
        case Remapper::TargetMeshWithGhosts:
            return m_target_set_with_ghosts;
        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_source_set_with_ghosts, m_target_set, m_target_set_with_ghosts, MB_SET_ERR_RET_VAL, moab::Remapper::OverlapMesh, moab::Remapper::SourceMesh, moab::Remapper::SourceMeshWithGhosts, moab::Remapper::TargetMesh, and moab::Remapper::TargetMeshWithGhosts.

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.

Definition at line 446 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::SourceMeshWithGhosts:
            return m_source_set_with_ghosts;
        case Remapper::TargetMeshWithGhosts:
            return m_target_set_with_ghosts;
        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_source_set_with_ghosts, m_target_set, m_target_set_with_ghosts, MB_SET_ERR_RET_VAL, moab::Remapper::OverlapMesh, moab::Remapper::SourceMesh, moab::Remapper::SourceMeshWithGhosts, moab::Remapper::TargetMesh, and moab::Remapper::TargetMeshWithGhosts.

GetMeshType()

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

inline

Get the mesh type corresponding to the intersection context

Definition at line 575 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:  // not need yet case Remapper::SourceMeshWithGhosts
        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

Definition at line 504 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.

Definition at line 520 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

Definition at line 705 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 && size > 1 )
    {
        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(), size, moab::Range::size(), and moab::subtract().

Referenced by main().

initialize()

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

virtual

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

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" );
        m_source_set_with_ghosts = m_source_set; // eventually, this will be overwritten by a new set, with ghosts
    }
    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_source_set_with_ghosts, 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

Definition at line 178 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.

Definition at line 153 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

Definition at line 397 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.

Definition at line 367 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:  // Remapper::SourceMeshWithGhosts does not need one
        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
	)

Definition at line 988 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 if( ctx == Remapper::SourceMeshWithGhosts )
    {
        m_source_set_with_ghosts = mset;  // entities not used
    }
    else if( ctx == Remapper::TargetMeshWithGhosts )
    {
        m_target_set_with_ghosts = mset;  // entities not used
    }
    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_source_set_with_ghosts, m_target_entities, m_target_set, m_target_set_with_ghosts, moab::Remapper::SourceMesh, moab::Remapper::SourceMeshWithGhosts, moab::Remapper::TargetMesh, and moab::Remapper::TargetMeshWithGhosts.

Referenced by CreateTempestMesh().

SetMeshType()

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

inline

Set the mesh type corresponding to the intersection context

Definition at line 536 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 asssociated 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.

Definition at line 952 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

Definition at line 273 of file TempestRemapper.hpp.

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

gid_to_lid_covsrc

std::map< int, int > moab::TempestRemapper::gid_to_lid_covsrc

private

Definition at line 333 of file TempestRemapper.hpp.

Referenced by clear(), ComputeGlobalLocalMaps(), convert_overlap_mesh_sorted_by_source(), and GetLocalID().

gid_to_lid_src

std::map< int, int > moab::TempestRemapper::gid_to_lid_src

private

Definition at line 333 of file TempestRemapper.hpp.

Referenced by clear(), ComputeGlobalLocalMaps(), and GetLocalID().

gid_to_lid_tgt

std::map< int, int > moab::TempestRemapper::gid_to_lid_tgt

private

Definition at line 333 of file TempestRemapper.hpp.

Referenced by clear(), ComputeGlobalLocalMaps(), convert_overlap_mesh_sorted_by_source(), and GetLocalID().

is_parallel

bool moab::TempestRemapper::is_parallel

private

Definition at line 344 of file TempestRemapper.hpp.

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

is_root

bool moab::TempestRemapper::is_root

private

Definition at line 344 of file TempestRemapper.hpp.

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

lid_to_gid_covsrc

std::map< int, int > moab::TempestRemapper::lid_to_gid_covsrc

private

Definition at line 334 of file TempestRemapper.hpp.

Referenced by clear(), ComputeGlobalLocalMaps(), and GetGlobalID().

lid_to_gid_src

std::map< int, int > moab::TempestRemapper::lid_to_gid_src

private

Definition at line 334 of file TempestRemapper.hpp.

Referenced by clear(), ComputeGlobalLocalMaps(), and GetGlobalID().

lid_to_gid_tgt

std::map< int, int > moab::TempestRemapper::lid_to_gid_tgt

private

Definition at line 334 of file TempestRemapper.hpp.

Referenced by clear(), ComputeGlobalLocalMaps(), and GetGlobalID().

m_area_method

IntxAreaUtils::AreaMethod moab::TempestRemapper::m_area_method

private

Definition at line 336 of file TempestRemapper.hpp.

m_covering_source

Mesh* moab::TempestRemapper::m_covering_source

private

Definition at line 327 of file TempestRemapper.hpp.

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

m_covering_source_entities

moab::Range moab::TempestRemapper::m_covering_source_entities

private

Definition at line 329 of file TempestRemapper.hpp.

Referenced by clear(), ComputeGlobalLocalMaps(), ConstructCoveringSet(), GetMeshEntities(), and SetMeshSet().

m_covering_source_set

moab::EntityHandle moab::TempestRemapper::m_covering_source_set

private

Definition at line 328 of file TempestRemapper.hpp.

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

m_covering_source_vertices

moab::Range moab::TempestRemapper::m_covering_source_vertices

private

Definition at line 330 of file TempestRemapper.hpp.

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

m_overlap

Mesh* moab::TempestRemapper::m_overlap

private

Definition at line 317 of file TempestRemapper.hpp.

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

m_overlap_entities

moab::Range moab::TempestRemapper::m_overlap_entities

private

Definition at line 319 of file TempestRemapper.hpp.

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

m_overlap_set

moab::EntityHandle moab::TempestRemapper::m_overlap_set

private

Definition at line 320 of file TempestRemapper.hpp.

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

m_overlap_type

TempestMeshType moab::TempestRemapper::m_overlap_type

private

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

m_source

Mesh* moab::TempestRemapper::m_source

private

Definition at line 297 of file TempestRemapper.hpp.

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

m_source_entities

moab::Range moab::TempestRemapper::m_source_entities

private

Definition at line 299 of file TempestRemapper.hpp.

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

m_source_metadata

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

private

Definition at line 304 of file TempestRemapper.hpp.

Referenced by SetMeshType().

m_source_set

moab::EntityHandle moab::TempestRemapper::m_source_set

private

Definition at line 301 of file TempestRemapper.hpp.

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

m_source_set_with_ghosts

moab::EntityHandle moab::TempestRemapper::m_source_set_with_ghosts

private

Definition at line 340 of file TempestRemapper.hpp.

Referenced by ConstructCoveringSet(), GetMeshSet(), initialize(), and SetMeshSet().

m_source_type

TempestMeshType moab::TempestRemapper::m_source_type

private

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

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

m_target

Mesh* moab::TempestRemapper::m_target

private

Definition at line 307 of file TempestRemapper.hpp.

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

m_target_entities

moab::Range moab::TempestRemapper::m_target_entities

private

Definition at line 309 of file TempestRemapper.hpp.

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

m_target_metadata

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

private

Definition at line 314 of file TempestRemapper.hpp.

Referenced by SetMeshType().

m_target_set

moab::EntityHandle moab::TempestRemapper::m_target_set

private

Definition at line 311 of file TempestRemapper.hpp.

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

m_target_set_with_ghosts

moab::EntityHandle moab::TempestRemapper::m_target_set_with_ghosts

private

Definition at line 341 of file TempestRemapper.hpp.

Referenced by GetMeshSet(), and SetMeshSet().

m_target_type

TempestMeshType moab::TempestRemapper::m_target_type

private

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

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

max_source_edges

int moab::TempestRemapper::max_source_edges

private

Definition at line 302 of file TempestRemapper.hpp.

Referenced by ConstructCoveringSet().

max_target_edges

int moab::TempestRemapper::max_target_edges

private

Definition at line 312 of file TempestRemapper.hpp.

Referenced by ConstructCoveringSet().

mbintx

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

private

Definition at line 324 of file TempestRemapper.hpp.

Referenced by ComputeOverlapMesh(), and ConstructCoveringSet().

meshValidate

bool moab::TempestRemapper::meshValidate

Definition at line 271 of file TempestRemapper.hpp.

Referenced by load_tempest_mesh_private(), and main().

offlineWorkflow

const bool moab::TempestRemapper::offlineWorkflow

Definition at line 270 of file TempestRemapper.hpp.

Referenced by convert_mesh_to_tempest_private().

point_cloud_source

bool moab::TempestRemapper::point_cloud_source

private

Definition at line 303 of file TempestRemapper.hpp.

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

point_cloud_target

bool moab::TempestRemapper::point_cloud_target

private

Definition at line 313 of file TempestRemapper.hpp.

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

rank

int moab::TempestRemapper::rank

private

Definition at line 345 of file TempestRemapper.hpp.

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

rrmgrids

bool moab::TempestRemapper::rrmgrids

private

Definition at line 343 of file TempestRemapper.hpp.

Referenced by ComputeOverlapMesh(), and ConstructCoveringSet().

size

int moab::TempestRemapper::size

private

Definition at line 345 of file TempestRemapper.hpp.

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

verbose

const bool moab::TempestRemapper::verbose = true

static

Definition at line 275 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