Overlapmesh lint algorithm

Makefile.am

@@ -23,6 +23,7 @@ libTempestRemap_la_include_HEADERS = \
 	src/TriangularQuadrature.h \
 	src/CommandLine.h \
 	src/Defines.h \
+	src/FunctionTimer.h \
 	src/GaussLobattoQuadrature.h \
 	src/kdtree.h \
 	src/order32.h \
@@ -55,6 +56,7 @@ libTempestRemap_la_include_HEADERS = \
 libTempestRemap_la_SOURCES = \
 	src/Announce.cpp \
 	src/PolynomialInterp.cpp \
+	src/FunctionTimer.cpp \
 	src/GridElements.cpp \
 	src/MeshUtilities.cpp \
 	src/MeshUtilitiesFuzzy.cpp \
@@ -68,8 +70,9 @@ libTempestRemap_la_SOURCES = \
 	src/GenerateUTMMesh.cpp \
 	src/GenerateGLLMetaData.cpp \
 	src/GenerateLambertConfConicMesh.cpp \
-	src/GenerateOverlapMesh.cpp \
-	src/GenerateOverlapMesh_v1.cpp \
+	src/GenerateOverlapMeshEdge.cpp \
+	src/GenerateOverlapMeshKdx.cpp \
+	src/GenerateOverlapMeshLint.cpp \
 	src/GaussQuadrature.cpp \
 	src/GaussLobattoQuadrature.cpp \
 	src/LegendrePolynomial.cpp \
@@ -110,12 +113,11 @@ GenerateVolumetricMesh_SOURCES = src/GenerateVolumetricMesh.cpp
 
 # Overlap mesh generators
 GenerateOverlapMesh_SOURCES = src/GenerateOverlapMeshExe.cpp
-GenerateOverlapMesh_v1_SOURCES = src/GenerateOverlapMeshExe_v1.cpp
+GenerateOverlapMeshParallel_SOURCES = src/GenerateOverlapMeshParallelExe.cpp
 
 # Compute and apply the offline mapping weights
 ApplyOfflineMap_SOURCES = src/ApplyOfflineMapExe.cpp
 GenerateOfflineMap_SOURCES = src/GenerateOfflineMapExe.cpp 
-# GenerateOfflineMap_v1_SOURCES = src/GenerateOfflineMap_v1.cpp
 
 GenerateGLLMetaData_SOURCES = src/GenerateGLLMetaDataExe.cpp
 GenerateTransposeMap_SOURCES = src/GenerateTransposeMap.cpp
@@ -134,7 +136,7 @@ bin_PROGRAMS = GenerateTestData \
 				GenerateCSMesh GenerateTransectMesh GenerateStereographicMesh GenerateRLLMesh \
 				GenerateUTMMesh GenerateICOMesh GenerateRectilinearMeshFromFile \
 				GenerateVolumetricMesh GenerateLambertConfConicMesh \
-				GenerateOverlapMesh GenerateOverlapMesh_v1 \
+				GenerateOverlapMesh GenerateOverlapMeshParallel \
 				ApplyOfflineMap GenerateOfflineMap \
 				CalculateDiffNorms GenerateGLLMetaData \
 				GenerateTransposeMap CoarsenRectilinearData \

src/Defines.h

@@ -68,7 +68,8 @@ static const Real ReferenceTolerance = 1.0e-12;
 // is the slowest).
 //
 //#define OVERLAPMESH_RETAIN_REPEATED_NODES
-#define OVERLAPMESH_USE_UNSORTED_MAP
+#define OVERLAPMESH_USE_SORTED_MAP
+//#define OVERLAPMESH_USE_UNSORTED_MAP
 //#define OVERLAPMESH_USE_NODE_MULTIMAP
 
 ///////////////////////////////////////////////////////////////////////////////

src/FiniteElementTools.cpp

@@ -294,7 +294,7 @@ double GenerateMetaData(
 
 	// Verify face areas are available
 	if (!fNoBubble) {
-		if (mesh.vecFaceArea.GetRows() != nElements) {
+		if (mesh.vecFaceArea.size() != nElements) {
 			_EXCEPTIONT("Face area information unavailable or incorrect");
 		}
 	}

src/FunctionTimer.cpp

@@ -0,0 +1,199 @@
+///////////////////////////////////////////////////////////////////////////////
+///
+///	\file    FunctionTimer.cpp
+///	\author  Paul Ullrich
+///	\version November 2, 2021
+///
+///	<remarks>
+///		Copyright 2021 Paul Ullrich
+///
+///		This file is distributed as part of the Tempest source code package.
+///		Permission is granted to use, copy, modify and distribute this
+///		source code and its documentation under the terms of the GNU General
+///		Public License.  This software is provided "as is" without express
+///		or implied warranty.
+///	</remarks>
+
+#include "FunctionTimer.h"
+#include "Exception.h"
+
+#include <iostream>
+#include <chrono>
+
+///////////////////////////////////////////////////////////////////////////////
+
+FunctionTimer::GroupDataMap FunctionTimer::m_mapGroupData;
+
+///////////////////////////////////////////////////////////////////////////////
+
+FunctionTimer::FunctionTimer(const char *szGroup) {
+
+	// Start the timer
+	m_fStopped = false;
+
+	// Assign group name
+	if (szGroup == NULL) {
+		m_strGroup = "";
+	} else {
+		m_strGroup = szGroup;
+	}
+
+	// Assign start time
+	m_tpStartTime = std::chrono::high_resolution_clock::now();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void FunctionTimer::Reset() {
+	m_fStopped = false;
+	m_tpStartTime = std::chrono::high_resolution_clock::now();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+std::chrono::microseconds FunctionTimer::Time(bool fDone) {
+
+	if (!m_fStopped) {
+		m_tpStopTime = std::chrono::high_resolution_clock::now();
+	}
+
+	std::chrono::microseconds msTime =
+		std::chrono::duration_cast<std::chrono::microseconds>(
+			m_tpStopTime - m_tpStartTime);
+
+	// If no name associated with this timer, ignore fDone.
+	if (m_strGroup == "") {
+		return msTime;
+	}
+
+	// Add the time to the group record
+	if ((fDone) && (!m_fStopped)) {
+		m_fStopped = true;
+
+		GroupDataMap::iterator iter;
+
+		iter = m_mapGroupData.find(m_strGroup);
+
+		// Add to existing group record
+		if (iter != m_mapGroupData.end()) {
+			iter->second.iTotalTime += msTime;
+			iter->second.nEntries++;
+
+		// Create new group record
+		} else {
+			GroupDataPair gdp;
+			gdp.first = m_strGroup;
+			gdp.second.iTotalTime = msTime;
+			gdp.second.nEntries = 1;
+
+			m_mapGroupData.insert(gdp);
+		}
+	}
+
+	return msTime;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+std::chrono::microseconds FunctionTimer::StopTime() {
+	return Time(true);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+const FunctionTimer::TimerGroupData & FunctionTimer::GetGroupTimeRecord(
+	const char *szName
+) {
+	GroupDataMap::iterator iter;
+
+	iter = m_mapGroupData.find(szName);
+
+	// Retrieve existing group record
+	if (iter != m_mapGroupData.end()) {
+		return iter->second;
+
+	// Group record does not exist
+	} else {
+		_EXCEPTION1("Group time record %s does not exist.", szName);
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+std::chrono::microseconds FunctionTimer::GetTotalGroupTime(const char *szName) {
+
+	GroupDataMap::iterator iter;
+
+	iter = m_mapGroupData.find(szName);
+
+	// Retrieve existing group record
+	if (iter != m_mapGroupData.end()) {
+		const TimerGroupData & tgd = iter->second;
+
+		return (tgd.iTotalTime);
+
+	// Group record does not exist
+	} else {
+		return std::chrono::microseconds(0);
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+std::chrono::microseconds FunctionTimer::GetAverageGroupTime(const char *szName) {
+
+	GroupDataMap::iterator iter;
+
+	iter = m_mapGroupData.find(szName);
+
+	// Retrieve existing group record
+	if (iter != m_mapGroupData.end()) {
+		const TimerGroupData & tgd = iter->second;
+
+		return (tgd.iTotalTime / tgd.nEntries);
+
+	// Group record does not exist
+	} else {
+		return std::chrono::microseconds(0);
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+unsigned long FunctionTimer::GetNumberOfEntries(const char *szName) {
+
+	GroupDataMap::iterator iter;
+
+	iter = m_mapGroupData.find(szName);
+
+	// Retrieve existing group record
+	if (iter != m_mapGroupData.end()) {
+		const TimerGroupData & tgd = iter->second;
+
+		return (tgd.nEntries);
+
+	// Group record does not exist
+	} else {
+		return 0;
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void FunctionTimer::ResetGroupTimeRecord(const char *szName) {
+	GroupDataMap::iterator iter;
+
+	iter = m_mapGroupData.find(szName);
+
+	// Retrieve existing group record
+	if (iter != m_mapGroupData.end()) {
+		m_mapGroupData.erase(iter);
+
+	// Group record does not exist
+	} else {
+		_EXCEPTION1("Group time record %s does not exist.", szName);
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+