From f2d3f32b3d0d868b954554102a79fdd39275bb9a Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Mon, 7 May 2018 22:13:03 -0400
Subject: [PATCH 01/37] Reorganization Update

-moved source files into new src directory
---
 Event.cpp => src/Event.cpp           | 0
 Event.h => src/Event.h               | 0
 Lattice.cpp => src/Lattice.cpp       | 0
 Lattice.h => src/Lattice.h           | 0
 Object.cpp => src/Object.cpp         | 0
 Object.h => src/Object.h             | 0
 Simulation.cpp => src/Simulation.cpp | 0
 Simulation.h => src/Simulation.h     | 0
 Site.cpp => src/Site.cpp             | 0
 Site.h => src/Site.h                 | 0
 Utils.cpp => src/Utils.cpp           | 0
 Utils.h => src/Utils.h               | 0
 12 files changed, 0 insertions(+), 0 deletions(-)
 rename Event.cpp => src/Event.cpp (100%)
 rename Event.h => src/Event.h (100%)
 rename Lattice.cpp => src/Lattice.cpp (100%)
 rename Lattice.h => src/Lattice.h (100%)
 rename Object.cpp => src/Object.cpp (100%)
 rename Object.h => src/Object.h (100%)
 rename Simulation.cpp => src/Simulation.cpp (100%)
 rename Simulation.h => src/Simulation.h (100%)
 rename Site.cpp => src/Site.cpp (100%)
 rename Site.h => src/Site.h (100%)
 rename Utils.cpp => src/Utils.cpp (100%)
 rename Utils.h => src/Utils.h (100%)

diff --git a/Event.cpp b/src/Event.cpp
similarity index 100%
rename from Event.cpp
rename to src/Event.cpp
diff --git a/Event.h b/src/Event.h
similarity index 100%
rename from Event.h
rename to src/Event.h
diff --git a/Lattice.cpp b/src/Lattice.cpp
similarity index 100%
rename from Lattice.cpp
rename to src/Lattice.cpp
diff --git a/Lattice.h b/src/Lattice.h
similarity index 100%
rename from Lattice.h
rename to src/Lattice.h
diff --git a/Object.cpp b/src/Object.cpp
similarity index 100%
rename from Object.cpp
rename to src/Object.cpp
diff --git a/Object.h b/src/Object.h
similarity index 100%
rename from Object.h
rename to src/Object.h
diff --git a/Simulation.cpp b/src/Simulation.cpp
similarity index 100%
rename from Simulation.cpp
rename to src/Simulation.cpp
diff --git a/Simulation.h b/src/Simulation.h
similarity index 100%
rename from Simulation.h
rename to src/Simulation.h
diff --git a/Site.cpp b/src/Site.cpp
similarity index 100%
rename from Site.cpp
rename to src/Site.cpp
diff --git a/Site.h b/src/Site.h
similarity index 100%
rename from Site.h
rename to src/Site.h
diff --git a/Utils.cpp b/src/Utils.cpp
similarity index 100%
rename from Utils.cpp
rename to src/Utils.cpp
diff --git a/Utils.h b/src/Utils.h
similarity index 100%
rename from Utils.h
rename to src/Utils.h

From 539f9b0e3410c2c186fb6e9c7c81f21dab5abacb Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Mon, 7 May 2018 22:14:04 -0400
Subject: [PATCH 02/37] Testing Setup

-added makefile
---
 makefile | 81 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 81 insertions(+)
 create mode 100644 makefile

diff --git a/makefile b/makefile
new file mode 100644
index 0000000..f4a09ec
--- /dev/null
+++ b/makefile
@@ -0,0 +1,81 @@
+# Copyright (c) 2018 Michael C. Heiber
+# This source file is part of the KMC_Lattice project, which is subject to the MIT License.
+# For more information, see the LICENSE file that accompanies this software.
+# The KMC_Lattice project can be found on Github at https://github.com/MikeHeiber/KMC_Lattice
+
+ifeq ($(lastword $(subst /, ,$(CXX))),g++)
+	FLAGS += -Wall -Wextra -O3 -std=c++11 -I. -Isrc
+endif
+ifeq ($(lastword $(subst /, ,$(CXX))),pgc++)
+	FLAGS += -O2 -fastsse -Mvect -std=c++11 -Mdalign -Munroll -Mipa=fast -Kieee -m64 -I. -Isrc
+endif
+
+OBJS = src/Event.o src/Lattice.o src/Object.o src/Simulation.o src/Site.o src/Utils.o
+
+all : libKMC.a
+ifndef FLAGS
+	$(error Valid compiler not detected.)
+endif
+
+libKMC.a : $(OBJS)
+	ar rcs $@ $^
+
+src/Event.o : src/Event.cpp src/Event.h src/Lattice.h src/Object.h src/Simulation.h src/Site.h src/Utils.h
+	mpicxx $(FLAGS) -c $< -o $@
+
+src/Lattice.o : src/Lattice.cpp src/Lattice.h src/Site.h src/Utils.h
+	mpicxx $(FLAGS) -c $< -o $@
+
+src/Object.o : src/Object.cpp src/Object.h src/Utils.h
+	mpicxx $(FLAGS) -c $< -o $@
+
+src/Simulation.o : src/Simulation.cpp src/Simulation.h src/Event.h src/Lattice.h src/Object.h src/Site.h src/Utils.h
+	mpicxx $(FLAGS) -c $< -o $@
+	
+src/Site.o : src/Site.cpp KMC_Lattice/Site.h
+	mpicxx $(FLAGS) -c $< -o $@
+	
+src/Utils.o : KMC_Lattice/Utils.cpp KMC_Lattice/Utils.h
+	mpicxx $(FLAGS) -c $< -o $@
+
+#
+# Testing Section using googletest
+#
+
+ifndef FLAGS
+	$(error Valid compiler not detected.)
+endif
+GTEST_DIR = googletest/googletest
+GTEST_HEADERS = $(GTEST_DIR)/include/gtest/*.h \
+                $(GTEST_DIR)/include/gtest/internal/*.h
+GTEST_SRCS_ = $(GTEST_DIR)/src/*.cc $(GTEST_DIR)/src/*.h $(GTEST_HEADERS)
+ifeq ($(lastword $(subst /, ,$(CXX))),g++)
+	GTEST_FLAGS = -isystem $(GTEST_DIR)/include -pthread
+endif
+ifeq ($(lastword $(subst /, ,$(CXX))),pgc++)
+	GTEST_FLAGS = -I$(GTEST_DIR)/include
+endif
+
+test : FLAGS = -fprofile-arcs -ftest-coverage -std=c++11 -Wall -Wextra -I. -Isrc
+test : test/KMC_Lattice_tests.exe	
+	
+test/KMC_Lattice_tests.exe : test/test.o test/gtest-all.o $(OBJS)
+	mpicxx $(GTEST_FLAGS) $(FLAGS) -lpthread $^ -o $@
+
+test/gtest-all.o : $(GTEST_SRCS_)
+	mpicxx $(GTEST_FLAGS) -I$(GTEST_DIR) $(FLAGS) -c $(GTEST_DIR)/src/gtest-all.cc -o $@
+			
+test/test.o : test/test.cpp $(GTEST_HEADERS) $(OBJS)
+	mpicxx $(GTEST_FLAGS) $(FLAGS) -c $< -o $@
+
+test_mpi : FLAGS = -fprofile-arcs -ftest-coverage -std=c++11 -Wall -Wextra -I. -Isrc
+test_mpi : test/KMC_Lattice_MPI_tests.exe
+
+test/Excimontec_MPI_tests.exe : test/test_mpi.o test/gtest-all.o $(OBJS)
+	mpicxx $(GTEST_FLAGS) $(FLAGS) -lpthread $^ -o $@
+
+test/test_mpi.o : test/test_mpi.cpp $(GTEST_HEADERS) $(OBJS)
+	mpicxx $(GTEST_FLAGS) $(FLAGS) -c $< -o $@
+	
+clean:
+	-rm src/*.o src/*.gcno* src/*.gcda KMC_Lattice/*.o KMC_Lattice/*.gcno* KMC_Lattice/*.gcda testing/*.o testing/*.gcno* testing/*.gcda *~ Excimontec.exe testing/*.o testing/Excimontec_tests.exe testing/Excimontec_mpi_tests.exe

From 3d6e5fb2a0f9a6e8ae00101dc7b165e064cb67f0 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Mon, 7 May 2018 22:14:31 -0400
Subject: [PATCH 03/37] Travis CI Setup

-added initial travis yml file
---
 .travis.yml | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 .travis.yml

diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..03f4a5f
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,46 @@
+# Copyright (c) 2018 Michael C. Heiber
+# This source file is part of the KMC_Lattice project, which is subject to the MIT License.
+# For more information, see the LICENSE file that accompanies this software.
+# The KMC_Lattice project can be found on Github at https://github.com/MikeHeiber/KMC_Lattice
+# Travis CI continuous integration build script
+
+language: cpp
+os: linux
+dist: trusty
+sudo: required
+
+compiler:
+    - gcc
+    
+env:
+    - COMPILER_OPTIONS="VERSION=4.7 && MPI=mpich2"
+    - COMPILER_OPTIONS="VERSION=4.7 && MPI=openmpi"
+    - COMPILER_OPTIONS="VERSION=4.8 && MPI=mpich2"
+    - COMPILER_OPTIONS="VERSION=4.8 && MPI=openmpi"
+    - COMPILER_OPTIONS="VERSION=4.9 && MPI=mpich2"
+    - COMPILER_OPTIONS="VERSION=4.9 && MPI=openmpi"
+    - COMPILER_OPTIONS="VERSION=5 && MPI=mpich2"
+    - COMPILER_OPTIONS="VERSION=5 && MPI=openmpi"
+    - COMPILER_OPTIONS="VERSION=6 && MPI=mpich2"
+    - COMPILER_OPTIONS="VERSION=6 && MPI=openmpi"
+    - COMPILER_OPTIONS="VERSION=7 && MPI=mpich2"
+    - COMPILER_OPTIONS="VERSION=7 && MPI=openmpi"
+    - COMPILER_OPTIONS="VERSION=8 && MPI=mpich2"
+    - COMPILER_OPTIONS="VERSION=8 && MPI=openmpi"
+         
+before_install:
+    - eval "${COMPILER_OPTIONS}"
+    - sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
+    - sudo apt-get update -qq
+    - sudo apt-get install -qq gcc-$VERSION g++-$VERSION -y
+    - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-$VERSION 60 --slave /usr/bin/g++ g++ /usr/bin/g++-$VERSION
+    - sudo update-alternatives --config gcc
+    - gcc --version
+    - if [[ "$MPI" = mpich2 ]]; then sudo apt-get -y install -qq mpich2 libmpich2-dev; fi
+    - if [[ "$MPI" = openmpi ]]; then sudo apt-get -y install -qq openmpi-bin libopenmpi-dev; fi
+    - pip install --user cpp-coveralls
+    
+script:
+    - make -j10 test && travis_wait ./test/KMC_Lattice_tests.exe
+    - make -j10 test_mpi && travis_wait mpiexec -n 4 ./test/KMC_Lattice_MPI_tests.exe
+    - coveralls --include src --exclude "googletest/*" --gcov-options '\-lp'

From bb3b167c874f9920d2b71f3aaab9e0346a7e4754 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Mon, 7 May 2018 22:16:22 -0400
Subject: [PATCH 04/37] Added googletest Submodule

---
 .gitmodules | 3 +++
 googletest  | 1 +
 2 files changed, 4 insertions(+)
 create mode 100644 .gitmodules
 create mode 160000 googletest

diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..7e38e13
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "googletest"]
+	path = googletest
+	url = https://github.com/google/googletest
diff --git a/googletest b/googletest
new file mode 160000
index 0000000..045e7f9
--- /dev/null
+++ b/googletest
@@ -0,0 +1 @@
+Subproject commit 045e7f9ee4f969ac1a3fe428f79c4b880f0aff43

From 8095a27c2d82ac7d0542b0472544597176d19426 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Mon, 7 May 2018 22:49:58 -0400
Subject: [PATCH 05/37] Makefile Update

-corrected a few path bugs in the makefile
---
 makefile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/makefile b/makefile
index f4a09ec..350874a 100644
--- a/makefile
+++ b/makefile
@@ -32,10 +32,10 @@ src/Object.o : src/Object.cpp src/Object.h src/Utils.h
 src/Simulation.o : src/Simulation.cpp src/Simulation.h src/Event.h src/Lattice.h src/Object.h src/Site.h src/Utils.h
 	mpicxx $(FLAGS) -c $< -o $@
 	
-src/Site.o : src/Site.cpp KMC_Lattice/Site.h
+src/Site.o : src/Site.cpp src/Site.h
 	mpicxx $(FLAGS) -c $< -o $@
 	
-src/Utils.o : KMC_Lattice/Utils.cpp KMC_Lattice/Utils.h
+src/Utils.o : src/Utils.cpp src/Utils.h
 	mpicxx $(FLAGS) -c $< -o $@
 
 #

From 39afd25c73efdb5cc7d37fd96065e39655e6598c Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Mon, 7 May 2018 22:55:55 -0400
Subject: [PATCH 06/37] Update Makefile

-corrected bug in makefile test target name
---
 makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/makefile b/makefile
index 350874a..18c810d 100644
--- a/makefile
+++ b/makefile
@@ -71,7 +71,7 @@ test/test.o : test/test.cpp $(GTEST_HEADERS) $(OBJS)
 test_mpi : FLAGS = -fprofile-arcs -ftest-coverage -std=c++11 -Wall -Wextra -I. -Isrc
 test_mpi : test/KMC_Lattice_MPI_tests.exe
 
-test/Excimontec_MPI_tests.exe : test/test_mpi.o test/gtest-all.o $(OBJS)
+test/KMC_Lattice_MPI_tests.exe : test/test_mpi.o test/gtest-all.o $(OBJS)
 	mpicxx $(GTEST_FLAGS) $(FLAGS) -lpthread $^ -o $@
 
 test/test_mpi.o : test/test_mpi.cpp $(GTEST_HEADERS) $(OBJS)

From 8fa2dd6dad400074a6bcb1e8b53570536c6cae72 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Mon, 7 May 2018 22:56:17 -0400
Subject: [PATCH 07/37] Testing Update

-added test cpp files for unit testing
---
 test/test.cpp     | 500 ++++++++++++++++++++++++++++++++++++++++++++++
 test/test_mpi.cpp | 100 ++++++++++
 2 files changed, 600 insertions(+)
 create mode 100644 test/test.cpp
 create mode 100644 test/test_mpi.cpp

diff --git a/test/test.cpp b/test/test.cpp
new file mode 100644
index 0000000..6b5f2a1
--- /dev/null
+++ b/test/test.cpp
@@ -0,0 +1,500 @@
+// Copyright (c) 2018 Michael C. Heiber
+// This source file is part of the KMC_Lattice project, which is subject to the MIT License.
+// For more information, see the LICENSE file that accompanies this software.
+// The KMC_Lattice project can be found on Github at https://github.com/MikeHeiber/KMC_Lattice
+
+#include "gtest/gtest.h"
+#include "Simulation.h"
+#include "Utils.h"
+
+
+using namespace std;
+using namespace Utils;
+
+// Simple derived Simulation class
+class TestSim : public Simulation {
+public:
+	bool checkFinished() const { return false; };
+	bool executeNextEvent() { return false; };
+};
+
+namespace UtilsTests {
+
+	TEST(UtilsTests, CoordsTests) {
+		Coords coords{ 1, 1, 1 };
+		EXPECT_EQ(1, coords.x);
+		EXPECT_EQ(1, coords.y);
+		EXPECT_EQ(1, coords.z);
+		Coords coords2{ 0, 5, 10 };
+		EXPECT_TRUE(coords != coords2);
+		coords2.setXYZ(1, 1, 1);
+		EXPECT_TRUE(coords == coords2);
+	}
+
+	TEST(UtilsTests, CalculateProbabilityHistTests) {
+		mt19937 gen(std::random_device{}());
+		uniform_real_distribution<> dist(0, 100);
+		vector<double> data((int)1e7);
+		for (int i = 0; i < (int)data.size(); i++) {
+			data[i] = dist(gen);
+		}
+		auto hist = calculateProbabilityHist(data, 10);
+		uniform_int_distribution<> dist2(0, 9);
+		EXPECT_EQ(10, (int)hist.size());
+		EXPECT_NEAR(1.0 / 100.0, hist[dist2(gen)].second,1e-4);
+		EXPECT_NEAR(1.0 / 100.0, hist[dist2(gen)].second, 1e-4);
+		EXPECT_NEAR(1.0 / 100.0, hist[dist2(gen)].second, 1e-4);
+		hist = calculateProbabilityHist(data, 10.0);
+		EXPECT_EQ(10, (int)hist.size());
+		EXPECT_NEAR(1.0 / 100.0, hist[dist2(gen)].second, 1e-4);
+		EXPECT_NEAR(1.0 / 100.0, hist[dist2(gen)].second, 1e-4);
+		EXPECT_NEAR(1.0 / 100.0, hist[dist2(gen)].second, 1e-4);
+	}
+
+	TEST(UtilsTests, ExponentialDOSTests) {
+		mt19937 gen(std::random_device{}());
+		vector<double> data((int)2e7, 0.0);
+		createExponentialDOSVector(data, 0.0, 0.1, gen);
+		auto hist = calculateProbabilityHist(data, 1000);
+		EXPECT_NEAR(1.0, integrateData(hist), 1e-4);
+		vector<double> prob;
+		for_each(hist.begin(), hist.end(), [&prob](pair<double, double>& x_y) {prob.push_back(x_y.second); });
+		double peak = *max_element(prob.begin(), prob.end());
+		EXPECT_NEAR(0.5*(1.0 / 0.1), peak, 1e-2*peak);
+		createExponentialDOSVector(data, 0.0, 0.05, gen);
+		hist = calculateProbabilityHist(data, 1000);
+		EXPECT_NEAR(1.0, integrateData(hist), 1e-4);
+		prob.clear();
+		for_each(hist.begin(), hist.end(), [&prob](pair<double, double>& x_y) {prob.push_back(x_y.second); });
+		peak = *max_element(prob.begin(), prob.end());
+		EXPECT_NEAR(0.5*(1.0 / 0.05), peak, 1e-2*peak);
+	}
+
+	TEST(UtilsTests, GaussianDOSTests) {
+		mt19937 gen(std::random_device{}());
+		vector<double> data((int)3e7, 0.0);
+		createGaussianDOSVector(data, 0.0, 0.15, gen);
+		EXPECT_NEAR(0.0, vector_avg(data), 1e-4);
+		EXPECT_NEAR(0.15, vector_stdev(data), 1e-4);
+		auto hist = calculateProbabilityHist(data, 1000);
+		EXPECT_NEAR(1.0, integrateData(hist), 1e-4);
+		double peak = hist[499].second;
+		EXPECT_NEAR(1.0 / sqrt(2.0*Pi*intpow(0.15, 2)), peak, 1e-1*peak);
+		createGaussianDOSVector(data, 0.0, 0.05, gen);
+		EXPECT_NEAR(0.0, vector_avg(data), 1e-4);
+		EXPECT_NEAR(0.05, vector_stdev(data), 1e-4);
+		hist = calculateProbabilityHist(data, 0.005);
+		EXPECT_NEAR(1.0, integrateData(hist), 1e-4);
+		vector<double> prob;
+		for_each(hist.begin(), hist.end(), [&prob](pair<double, double>& x_y) {prob.push_back(x_y.second); });
+		peak = *max_element(prob.begin(), prob.end());
+		EXPECT_NEAR(1.0 / sqrt(2.0*Pi*intpow(0.05, 2)), peak, 1e-1*peak);
+	}
+
+	TEST(UtilsTests, ImportBooleanTests) {
+		bool error_status;
+		EXPECT_TRUE(importBooleanParam("true", error_status));
+		EXPECT_TRUE(importBooleanParam(" true  ", error_status));
+		EXPECT_FALSE(importBooleanParam("false	", error_status));
+		EXPECT_FALSE(importBooleanParam("   false", error_status));
+		EXPECT_FALSE(importBooleanParam("blah", error_status));
+		EXPECT_FALSE(importBooleanParam("	blah  ", error_status));
+		EXPECT_TRUE(error_status);
+	}
+
+	TEST(UtilsTests, IntegrateDataTests) {
+		vector<pair<double, double>> data_vec = { {0.0,0.0},{1.0,1.0},{2.0,2.0},{3.0,3.0} };
+		auto area = integrateData(data_vec);
+		EXPECT_DOUBLE_EQ(area, 9.0 / 2.0);
+	}
+
+	TEST(UtilsTests, InterpolateDataTests) {
+		vector<pair<double, double>> data_vec(100);
+		for (int i = 0; i < (int)data_vec.size();i++) {
+			data_vec[i].first = 0.1*i;
+			data_vec[i].second = exp(-data_vec[i].first/2.85);
+		}
+		EXPECT_NEAR(1 / exp(1), interpolateData(data_vec, 2.85), 1e-4);
+		for (int i = 0; i < (int)data_vec.size(); i++) {
+			data_vec[i].first = 0.2*i;
+			data_vec[i].second = 2.5*data_vec[i].first - 5.0;
+		}
+		EXPECT_NEAR(3.25, interpolateData(data_vec, 3.3), 1e-4);
+	}
+
+	TEST(UtilsTests, RemoveWhitespaceTests) {
+		string str = " text          ";
+		EXPECT_EQ(removeWhitespace(str), "text");
+		str = " text	";
+		EXPECT_EQ(removeWhitespace(str), "text");
+		str = "			text ";
+		EXPECT_EQ(removeWhitespace(str), "text");
+	}
+
+	TEST(UtilsTests, ArrayStatsTests) {
+		// positive ints
+		int int_data[10];
+		for (int i = 0; i < 10; i++) {
+			int_data[i] = i + 1;
+		}
+		EXPECT_DOUBLE_EQ(5.5, array_avg(int_data, 10));
+		EXPECT_NEAR(3.02765035409749, array_stdev(int_data, 10), 1e-14);
+		// negative ints
+		for (int i = 0; i < 10; i++) {
+			int_data[i] = -(i + 1);
+		}
+		EXPECT_DOUBLE_EQ(-5.5, array_avg(int_data, 10));
+		EXPECT_NEAR(3.02765035409749, array_stdev(int_data, 10), 1e-14);
+		// positive doubles
+		double double_data[10];
+		for (int i = 0; i < 10; i++) {
+			double_data[i] = 0.5*(i + 1);
+		}
+		EXPECT_DOUBLE_EQ(2.75, array_avg(double_data, 10));
+		EXPECT_NEAR(1.51382517704875, array_stdev(double_data, 10), 1e-14);
+		// negative doubles
+		for (int i = 0; i < 10; i++) {
+			double_data[i] = -0.5*(i + 1);
+		}
+		EXPECT_DOUBLE_EQ(-2.75, array_avg(double_data, 10));
+		EXPECT_NEAR(1.51382517704875, array_stdev(double_data, 10), 1e-14);
+	}
+
+	TEST(UtilsTests, IntPowTests) {
+		EXPECT_DOUBLE_EQ(1.0, intpow(2.5, 0));
+		EXPECT_DOUBLE_EQ(2.5, intpow(2.5, 1));
+		EXPECT_DOUBLE_EQ(6.25, intpow(2.5, 2));
+		EXPECT_DOUBLE_EQ(9536.7431640625, intpow(2.5, 10));
+		EXPECT_DOUBLE_EQ(0.4, intpow(2.5, -1));
+		EXPECT_DOUBLE_EQ(0.16, intpow(2.5, -2));
+		EXPECT_DOUBLE_EQ(1.048576e-4, intpow(2.5, -10));
+		EXPECT_DOUBLE_EQ(1.0, intpow(15.04564, 0));
+		EXPECT_DOUBLE_EQ(1e-21, intpow(1e-7, 3));
+	}
+
+	TEST(UtilsTests, RemoveDuplicatesTests) {
+		vector<int> vec{ 0, 1, 1, 2, 3, 1, 4, 2 };
+		removeDuplicates(vec);
+		EXPECT_EQ(2, vec[2]);
+		EXPECT_EQ(5, (int)vec.size());
+		vec = { 0, 1, 2, 1 };
+		removeDuplicates(vec);
+		EXPECT_EQ(2, vec[2]);
+		EXPECT_EQ(3, (int)vec.size());
+		vector<double> vec2{ 0.0, 1.0, 1.0, 2.0, 3.0, 1.0, 4.0, 2.0 };
+		removeDuplicates(vec2);
+		EXPECT_DOUBLE_EQ(2.0, vec2[2]);
+		EXPECT_EQ(5, (int)vec2.size());
+		Coords coords1{ 1,2,3 };
+		Coords coords2{ 1,2,3 };
+		Coords coords3{ 4,5,6 };
+		vector<Coords> vec3{ coords1, coords1, coords2, coords3, coords1, coords3, coords2 };
+		removeDuplicates(vec3);
+		EXPECT_EQ(4, vec3[1].x);
+		EXPECT_EQ(2, (int)vec3.size());
+		Object object1(0, 1, { 0,0,0 });
+		Object object2(0, 2, { 1,1,1 });
+		vector<Object*> object_ptrs{ &object1, &object1, &object2, &object1, &object2 };
+		removeDuplicates(object_ptrs);
+		EXPECT_EQ(2, (int)object_ptrs.size());
+		vector<int> vec4 = {};
+		removeDuplicates(vec4);
+		EXPECT_EQ(0, (int)vec4.size());
+		vector<int> vec5 = { 0 };
+		removeDuplicates(vec5);
+		EXPECT_EQ(1, (int)vec5.size());
+		vector<int> vec6 = { 0,0 };
+		removeDuplicates(vec6);
+		EXPECT_EQ(1, (int)vec6.size());
+	}
+
+	TEST(UtilsTests, VectorStatsTests) {
+		// positive ints
+		vector<int> int_data;
+		int_data.assign(10, 0);
+		for (int i = 0; i < 10; i++) {
+			int_data[i] = i + 1;
+		}
+		EXPECT_DOUBLE_EQ(5.5, vector_avg(int_data));
+		EXPECT_NEAR(3.02765035409749, vector_stdev(int_data), 1e-14);
+		// negative ints
+		for (int i = 0; i < 10; i++) {
+			int_data[i] = -(i + 1);
+		}
+		EXPECT_DOUBLE_EQ(-5.5, vector_avg(int_data));
+		EXPECT_NEAR(3.02765035409749, vector_stdev(int_data), 1e-14);
+		// positive doubles
+		vector<double> double_data;
+		double_data.assign(10, 0);
+		for (int i = 0; i < 10; i++) {
+			double_data[i] = 0.5*(i + 1);
+		}
+		EXPECT_DOUBLE_EQ(2.75, vector_avg(double_data));
+		EXPECT_NEAR(1.51382517704875, vector_stdev(double_data), 1e-14);
+		// negative doubles
+		double_data.assign(10, 0);
+		for (int i = 0; i < 10; i++) {
+			double_data[i] = -0.5*(i + 1);
+		}
+		EXPECT_DOUBLE_EQ(-2.75, vector_avg(double_data));
+		EXPECT_NEAR(1.51382517704875, vector_stdev(double_data), 1e-14);
+	}
+}
+
+namespace LatticeTests{
+		
+	class LatticeTest : public ::testing::Test {
+		protected:
+			mt19937 gen;
+			Parameters_Lattice params_lattice;
+			vector<Site> sites;
+			Lattice lattice;
+
+			void SetUp() {
+				gen.seed(std::random_device{}());
+				// Setup params
+				params_lattice.Enable_periodic_x = true;
+				params_lattice.Enable_periodic_y = true;
+				params_lattice.Enable_periodic_z = true;
+				params_lattice.Length = 50;
+				params_lattice.Width = 50;
+				params_lattice.Height = 50;
+				params_lattice.Unit_size = 1.0;
+				// Initialize Lattice object
+				lattice.init(params_lattice, &gen);
+				Site site;
+				sites.assign(lattice.getNumSites(), site);
+				vector<Site*> site_ptrs((int)sites.size());
+				for (int i = 0; i < (int)sites.size(); i++) {
+					site_ptrs[i] = &sites[i];
+				}
+				lattice.setSitePointers(site_ptrs);
+			}
+	};
+
+	TEST_F(LatticeTest, InitializationTests) {
+		EXPECT_EQ(50, lattice.getLength());
+		EXPECT_EQ(50, lattice.getWidth());
+		EXPECT_EQ(50, lattice.getHeight());
+		EXPECT_DOUBLE_EQ(1.0, lattice.getUnitSize());
+		EXPECT_EQ((long int)50 * 50 * 50, lattice.getNumSites());
+	}
+
+	TEST_F(LatticeTest, CalculateDestCoordsTests) {
+		Coords coords_i{ 49, 49, 49 };
+		Coords coords_f;
+		lattice.calculateDestinationCoords(coords_i, 2, -2, 0, coords_f);
+		EXPECT_EQ(1, coords_f.x);
+		EXPECT_EQ(47, coords_f.y);
+		EXPECT_EQ(49, coords_f.z);
+		coords_i.setXYZ(0, 0, 49);
+		lattice.calculateDestinationCoords(coords_i, 1, -2, 2, coords_f);
+		EXPECT_EQ(1, coords_f.x);
+		EXPECT_EQ(48, coords_f.y);
+		EXPECT_EQ(1, coords_f.z);
+	}
+
+	TEST_F(LatticeTest, PeriodicCrossingTests) {
+		Coords coords_i{ 49, 49, 49 };
+		Coords coords_f{ 0, 49, 48 };
+		EXPECT_EQ(lattice.calculateDX(coords_i, coords_f), -50);
+		EXPECT_EQ(lattice.calculateDY(coords_i, coords_f), 0);
+		EXPECT_EQ(lattice.calculateDZ(coords_i, coords_f), 0);
+		coords_i.setXYZ(0, 0, 49);
+		coords_f.setXYZ(1, 49, 0);
+		EXPECT_EQ(lattice.calculateDX(coords_i, coords_f), 0);
+		EXPECT_EQ(lattice.calculateDY(coords_i, coords_f), 50);
+		EXPECT_EQ(lattice.calculateDZ(coords_i, coords_f), -50);
+		coords_i.setXYZ(4, 5, 6);
+		coords_f.setXYZ(3, 6, 5);
+		EXPECT_EQ(lattice.calculateDX(coords_i, coords_f), 0);
+		EXPECT_EQ(lattice.calculateDY(coords_i, coords_f), 0);
+		EXPECT_EQ(lattice.calculateDZ(coords_i, coords_f), 0);
+	}
+
+	TEST_F(LatticeTest, CheckMoveValidityTests) {
+		params_lattice.Enable_periodic_x = false;
+		params_lattice.Enable_periodic_y = false;
+		params_lattice.Enable_periodic_z = true;
+		Lattice lattice2;
+		lattice2.init(params_lattice, &gen);
+		Coords coords1{ 49, 0, 49 };
+		EXPECT_FALSE(lattice2.checkMoveValidity(coords1, 1, 0, 0));
+		EXPECT_FALSE(lattice2.checkMoveValidity(coords1, 0, -1, 0));
+		EXPECT_TRUE(lattice2.checkMoveValidity(coords1, 0, 0, 1));
+		EXPECT_TRUE(lattice2.checkMoveValidity(coords1, -1, 1, -1));
+	}
+
+	TEST_F(LatticeTest, RandomSiteGenTests) {
+		Coords coords;
+		int N_test = 40000000;
+		vector<int> xcoords(N_test);
+		vector<int> ycoords(N_test);
+		vector<int> zcoords(N_test);
+		for (int i = 0; i < N_test; i++) {
+			coords = lattice.generateRandomCoords();
+			EXPECT_TRUE(coords.x >= 0 && coords.x < lattice.getLength());
+			EXPECT_TRUE(coords.y >= 0 && coords.y < lattice.getWidth());
+			EXPECT_TRUE(coords.z >= 0 && coords.z < lattice.getHeight());
+			xcoords[i] = coords.x;
+			ycoords[i] = coords.y;
+			zcoords[i] = coords.z;
+		}
+		EXPECT_NEAR(24.5, vector_avg(xcoords), 2e-2);
+		EXPECT_NEAR(lattice.getLength() / sqrt(12.0), vector_stdev(xcoords), 1e-2);
+		EXPECT_NEAR(24.5, vector_avg(ycoords), 2e-2);
+		EXPECT_NEAR(lattice.getWidth() / sqrt(12.0), vector_stdev(ycoords), 1e-2);
+		EXPECT_NEAR(24.5, vector_avg(zcoords), 2e-2);
+		EXPECT_NEAR(lattice.getHeight() / sqrt(12.0), vector_stdev(zcoords), 1e-2);
+	}
+
+	TEST_F(LatticeTest, LatticeDistanceTests) {
+		Coords coords_i{ 49, 49, 49 };
+		Coords coords_f{ 1, 49, 47 };
+		EXPECT_EQ(8, lattice.calculateLatticeDistanceSquared(coords_i, coords_f));
+		coords_i.setXYZ(4, 5, 6);
+		coords_f.setXYZ(3, 6, 5);
+		EXPECT_EQ(3, lattice.calculateLatticeDistanceSquared(coords_i, coords_f));
+		coords_i.setXYZ(0, 49, 1);
+		coords_f.setXYZ(48, 1, 49);
+		EXPECT_EQ(12, lattice.calculateLatticeDistanceSquared(coords_i, coords_f));
+	}
+
+	TEST_F(LatticeTest, GetSiteCoordsTests) {
+		Coords coords1, coords2;
+		int index;
+		for (int i = 0; i < 100; i++) {
+			coords1 = lattice.generateRandomCoords();
+			index = lattice.getSiteIndex(coords1);
+			coords2 = lattice.getSiteCoords(index);
+			EXPECT_EQ(coords1.x, coords2.x);
+			EXPECT_EQ(coords1.y, coords2.y);
+			EXPECT_EQ(coords1.z, coords2.z);
+		}
+	}
+
+	TEST_F(LatticeTest, OccupancyTests) {
+		Coords coords;
+		for (int x = 0; x < lattice.getLength(); x++) {
+			for (int y = 0; y < lattice.getWidth(); y++) {
+				for (int z = 0; z < lattice.getHeight(); z++) {
+					coords.setXYZ(x, y, z);
+					EXPECT_FALSE(lattice.isOccupied(coords));
+				}
+			}
+		}
+		coords.setXYZ(5, 5, 5);
+		lattice.setOccupied(coords);
+		EXPECT_TRUE(lattice.isOccupied(coords));
+		for (int x = 0; x < lattice.getLength(); x++) {
+			for (int y = 0; y < lattice.getWidth(); y++) {
+				for (int z = 0; z < lattice.getHeight(); z++) {
+					if (lattice.isOccupied(coords)) {
+						EXPECT_EQ(5, coords.x);
+						EXPECT_EQ(5, coords.y);
+						EXPECT_EQ(5, coords.z);
+					}
+				}
+			}
+		}
+		lattice.clearOccupancy(coords);
+		EXPECT_FALSE(lattice.isOccupied(coords));
+	}
+
+	TEST_F(LatticeTest, SetSitePointersTests) {
+		Site site;
+		vector<Site*> site_ptrs(10, &site);
+		EXPECT_FALSE(lattice.setSitePointers(site_ptrs));
+		site_ptrs.assign(50 * 50 * 50, &site);
+		EXPECT_TRUE(lattice.setSitePointers(site_ptrs));
+	}
+}
+
+namespace EventTests {
+
+	class EventTest : public ::testing::Test {
+	protected:
+		Parameters_Simulation params_base;
+		TestSim test_sim;
+		void setUp(){
+			{
+			params_base.Enable_logging = false;
+			params_base.Enable_periodic_x = true;
+			params_base.Enable_periodic_y = true;
+			params_base.Enable_periodic_z = true;
+			params_base.Length = 50;
+			params_base.Width = 50;
+			params_base.Height = 50;
+			params_base.Unit_size = 1.0;
+			params_base.Temperature = 300;
+			params_base.Enable_FRM = false;
+			params_base.Enable_selective_recalc = true;
+			params_base.Recalc_cutoff = 3;
+			params_base.Enable_full_recalc = false;
+			}
+			// Initialize TestSim object
+			test_sim.init(params_base, 0);
+		}
+	};
+
+	TEST_F(EventTest, CalculateExecutionTimeTests) {
+		Event event(&test_sim);
+		// Generate collection of wait times
+		vector<double> times((int)3e7);
+		for (int i = 0; i < (int)times.size(); i++) {
+			event.calculateExecutionTime(1e9);
+			times[i] = event.getExecutionTime();
+		}
+		// Calculate probability distribution of calculated times
+		auto hist = calculateProbabilityHist(times, 1000);
+		// Test probability distribution
+		EXPECT_NEAR(1.0, integrateData(hist), 2e-2);
+		EXPECT_NEAR(1e9, hist[0].second, 2e7);
+		auto it = find_if(hist.begin(), hist.end(), [](pair<double, double>& x_y) {return x_y.first > 1e-9; });
+		it--;
+		EXPECT_NEAR(1e9 / 2.7182818284590, (*it).second, 2e7);
+		// Test average wait time
+		EXPECT_NEAR(vector_avg(times), 1e-9, 2e-12);
+		// Generate collection of wait times
+		for (int i = 0; i < (int)times.size(); i++) {
+			event.calculateExecutionTime(1e12);
+			times[i] = event.getExecutionTime();
+		}
+		// Calculate probability distribution of calculated times
+		hist = calculateProbabilityHist(times, 1000);
+		// Test probability distribution
+		EXPECT_NEAR(1.0, integrateData(hist), 2e-2);
+		EXPECT_NEAR(1e12, hist[0].second, 2e10);
+		it = find_if(hist.begin(), hist.end(), [](pair<double, double>& x_y) {return x_y.first > 1e-12; });
+		it--;
+		EXPECT_NEAR(1e12 / 2.7182818284590, (*it).second, 2e10);
+		// Test average wait time
+		EXPECT_NEAR(vector_avg(times), 1e-12, 2e-15);
+	}
+}
+
+namespace ObjectTests {
+	
+	TEST(ObjectTests, CalculateDisplacementTests) {
+		// Assume object is created in a 50 x 50 x 50 lattice
+		Object object1(0, 1, { 0,0,0 });
+		object1.setCoords({ 0,0,5 });
+		EXPECT_DOUBLE_EQ(5.0, object1.calculateDisplacement());
+		object1.setCoords({ 0,0,49 });
+		object1.incrementDZ(-50);
+		EXPECT_DOUBLE_EQ(1.0, object1.calculateDisplacement());
+		object1.setCoords({ 49,49,49 });
+		object1.incrementDX(-50);
+		object1.incrementDY(-50);
+		EXPECT_DOUBLE_EQ(sqrt(3), object1.calculateDisplacement());
+		object1.setCoords({ 49,0,49 });
+		object1.incrementDY(50);
+		EXPECT_DOUBLE_EQ(sqrt(2), object1.calculateDisplacement());
+	}
+}
+
+
+int main(int argc, char **argv) {
+	::testing::InitGoogleTest(&argc, argv);
+	return RUN_ALL_TESTS();
+}
diff --git a/test/test_mpi.cpp b/test/test_mpi.cpp
new file mode 100644
index 0000000..971c5d4
--- /dev/null
+++ b/test/test_mpi.cpp
@@ -0,0 +1,100 @@
+// Copyright (c) 2018 Michael C. Heiber
+// This source file is part of the KMC_Lattice project, which is subject to the MIT License.
+// For more information, see the LICENSE file that accompanies this software.
+// The KMC_Lattice project can be found on Github at https://github.com/MikeHeiber/KMC_Lattice
+
+#include "gtest/gtest.h"
+#include "Utils.h"
+#include <mpi.h>
+
+using namespace std;
+using namespace Utils;
+
+namespace MPI_Tests {
+
+	class MPI_Test : public ::testing::Test {
+	protected:
+		int procid;
+		int nproc;
+		void SetUp() {
+			MPI_Comm_size(MPI_COMM_WORLD, &nproc);
+			MPI_Comm_rank(MPI_COMM_WORLD, &procid);
+		}
+	};
+
+	TEST_F(MPI_Test, CalculateVectorAvgTests) {
+		// Seteup unique data vectors on each proc
+		vector<double> data(3);
+		for (int i = 0; i < (int)data.size(); i++) {
+			data[i] = 3 * procid + i;
+		}
+		vector<double> data_avg = MPI_calculateVectorAvg(data);
+		if (procid == 0) {
+			EXPECT_EQ(3, (int)data_avg.size());
+			EXPECT_DOUBLE_EQ(4.5, data_avg[0]);
+			EXPECT_DOUBLE_EQ(5.5, data_avg[1]);
+			EXPECT_DOUBLE_EQ(6.5, data_avg[2]);
+		}
+	}
+
+	TEST_F(MPI_Test, CalculateVectorSumTests) {
+		// Seteup unique data vectors on each proc
+		vector<double> data(3);
+		for (int i = 0; i < (int)data.size(); i++) {
+			data[i] = 3 * procid + i;
+		}
+		vector<double> data_sum = MPI_calculateVectorSum(data);
+		if (procid == 0) {
+			EXPECT_EQ(3, (int)data_sum.size());
+			EXPECT_DOUBLE_EQ(18.0, data_sum[0]);
+			EXPECT_DOUBLE_EQ(22.0, data_sum[1]);
+			EXPECT_DOUBLE_EQ(26.0, data_sum[2]);
+		}
+		vector<int> data2(3);
+		for (int i = 0; i < (int)data2.size(); i++) {
+			data2[i] = 3 * procid + i;
+		}
+		vector<int> data_sum2 = MPI_calculateVectorSum(data2);
+		if (procid == 0) {
+			EXPECT_EQ(3, (int)data_sum2.size());
+			EXPECT_EQ(18, data_sum2[0]);
+			EXPECT_EQ(22, data_sum2[1]);
+			EXPECT_EQ(26, data_sum2[2]);
+		}
+	}
+
+	TEST_F(MPI_Test, GatherVectorsTests) {
+		// Seteup unique data vectors on each proc
+		vector<double> data(3);
+		for (int i = 0; i < (int)data.size(); i++) {
+			data[i] = 3 * procid + i;
+		}
+		vector<double> data_all = MPI_gatherVectors(data);
+		if (procid == 0) {
+			EXPECT_EQ(12, (int)data_all.size());
+			for (int i = 0; i < 3 * nproc; i++) {
+				EXPECT_DOUBLE_EQ((double)i, data_all[i]);
+			}
+		}
+		vector<int> data2(3);
+		for (int i = 0; i < (int)data2.size(); i++) {
+			data2[i] = 3 * procid + i;
+		}
+		vector<int> data_all2 = MPI_gatherVectors(data2);
+		if (procid == 0) {
+			EXPECT_EQ(12, (int)data_all2.size());
+			for (int i = 0; i < 3 * nproc; i++) {
+				EXPECT_EQ(i, data_all2[i]);
+			}
+		}
+	}
+}
+
+int main(int argc, char **argv) {
+	int result = 0;
+	::testing::InitGoogleTest(&argc, argv);
+	MPI_Init(&argc, &argv);
+	result = RUN_ALL_TESTS();
+	MPI_Finalize();
+	return result;
+}

From 7381ce4667e7183811fe5b4923d127f63ae8137c Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Mon, 7 May 2018 22:56:53 -0400
Subject: [PATCH 08/37] Readme Update

-added new readme content with CI and testing information and badges
---
 README.md | 57 +++++++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 53 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 4f33573..f17fef4 100644
--- a/README.md
+++ b/README.md
@@ -3,18 +3,67 @@
 ## General Information
 This object-oriented C++ software package contains a general framework for lattice kinetic Monte Carlo (KMC) simulations. 
 This framework consists of a number of utility functions and base classes that must be extended to create a fully operational KMC simulation. 
-The goal of this package is to be robust and flexible so that users can easily develop KMC simulations for a wide variety of different scientific problems without the need to start from scratch.
+The goal of this package is to be robust, reliable, and flexible so that users can easily develop KMC simulations for a wide variety of different scientific problems without the need to start from scratch.
 
 This KMC_Lattice package implements several event recalculation options for creating computationally efficient simulations. 
 The package is designed to be usable on a personal computer and on high performance computing clusters. 
-A simple example implementation of this general KMC framework can be found in the [KMC_Lattice_example](https://github.com/MikeHeiber/KMC_Lattice_example) package. 
-To see a more complete implementation for simulating a complex system, check out the [Excimontec](https://github.com/MikeHeiber/Excimontec) software package that is used for simulating organic semiconductor materials and devices.
+Check out the [Excimontec](https://github.com/MikeHeiber/Excimontec) software package for an example of a complex tool constructed using KMC_Lattice, which is used for simulating organic semiconductor materials and devices.
 
 For further reading about kinetic Monte Carlo simulations, a nice overview of the theory and algorithm can be found here:
 
 [Introduction to the Kinetic Monte Carlo Method by Arthur Voter, Los Alamos National Lab](http://www.fml.t.u-tokyo.ac.jp/~izumi/CMS/MC/Introduction_kMC.pdf)
 
-## Work Together
+## Current Status
+
+The current release is KMC_Lattice [![GitHub (pre-)release](https://img.shields.io/github/release/MikeHeiber/KMC_Lattice/all.svg?style=flat-square)](https://github.com/MikeHeiber/KMC_Lattice/releases) 
+Most major planned features that are to be included in v2.0 are now implemented and have undergone preliminary testing. 
+However, this software tool is still under development, and as such, there may still be bugs that need to be squashed. 
+Please report any bugs or submit feature requests in the [Issues](https://github.com/MikeHeiber/KMC_Lattice/issues) section. 
+
+#### Continuous Integration and Testing Status:
+
+KMC_Lattice is currently being tested on [Ubuntu](https://www.ubuntu.com/) v14.04 with the [GCC compiler](https://gcc.gnu.org/) (versions 4.7, 4.8, 4.9, 5, 6, 7, and 8) and on both [Open MPI](http://www.open-mpi.org/) v1.6.5 and [MPICH](http://www.mpich.org/) v3.04 using [Travis CI](https://travis-ci.com/).
+
+| Branch | Status |
+| :------: | ------ |
+| Master | [![Build Status](https://img.shields.io/travis/MikeHeiber/KMC_Lattice/master.svg?style=for-the-badge)](https://travis-ci.org/MikeHeiber/KMC_Lattice) |
+| Development | [![Build Status](https://img.shields.io/travis/MikeHeiber/KMC_Lattice/development.svg?style=for-the-badge)](https://travis-ci.org/MikeHeiber/KMC_Lattice) |
+
+Code is being tested using [googletest](https://github.com/google/googletest) with test coverage assessment by [Coveralls](https://coveralls.io/).
+
+| Branch | Status |
+| :------: | ------ |
+| Master | [![Coveralls github branch](https://img.shields.io/coveralls/github/MikeHeiber/KMC_Lattice/master.svg?style=for-the-badge)](https://coveralls.io/github/MikeHeiber/KMC_Lattice?branch=master) |
+| Development | [![Coveralls github branch](https://img.shields.io/coveralls/github/MikeHeiber/KMC_Lattice/development.svg?style=for-the-badge)](https://coveralls.io/github/MikeHeiber/KMC_Lattice?branch=development) |
+
+## Contact
+
+If you would like to contribute to the development of this project or would like some help in using the tool for your research, please contact me (heiber@mailaps.org) to discuss a collaboration. 
+You can check out my KMC research and other work on [Researchgate](https://www.researchgate.net/profile/Michael_Heiber).
+
+## How to try KMC_Lattice?
+
+#### Building and Testing the KMC_Lattice Library
+
+This software tool uses [Message Passing Interface (MPI)](https://computing.llnl.gov/tutorials/mpi/) to utilize parallel computing power. 
+As a result, using KMC_Lattice requires that an MPI library is pre-installed on your system, and the final KMC_Lattice library must be built on your specific system. 
+We cannot provide pre-built binaries for your system. 
+Contact your HPC admin to determine the protocols for building MPI applications on your HPC system. 
+In many cases, the HPC system will already be configured for you, and the package comes with a default makefile that can be used with the [GCC compiler](https://gcc.gnu.org/) or the [PGI compiler](https://www.pgroup.com/). 
+
+If you wish, you can also install MPI on your own personal workstation and then build the KMC_Lattice library there as well. For development and preliminary simulation tests, sometimes it is more efficient to run on your own workstation instead of an HPC system. More information about common MPI packages can be found here:
+- Open MPI, http://www.open-mpi.org/
+- MPICH, http://www.mpich.org/
+- MVAPICH, http://mvapich.cse.ohio-state.edu/
+
+Once you have an MPI library installed, to build the KMC_Lattice library, copy the KMC_Lattice directory to your machine, set it as your working directory, and run `make`. 
+Compilation flags have been set for GCC and PGI compilers.  If you are using another compiler, you will need to edit the makefile and define your own compiler options.
+However, before you use the KMC_Lattice library, you should test it on your own hardware using the unit and system tests provided. 
+Build the testing executable by running `make test`. 
+Once the test build is complete, run `./test/KMC_Lattice_tests.exe`.
+Please report any build or testing errors in the [Issues](https://github.com/MikeHeiber/KMC_Lattice/issues) section. 
+
+## Contact
 
 If you would like to contribute to the development of this project or would like some help in building an efficient KMC simulation tool for your specific scientific problem, please contact me to discuss a collaboration. 
 You can check out my KMC research and other work on [Researchgate](https://www.researchgate.net/profile/Michael_Heiber).

From fb67a2e5d7592958b5c29df5ebb1601b50637f46 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Tue, 8 May 2018 10:20:14 -0400
Subject: [PATCH 09/37] Utils Testing Update

-simplified data input validation and testing of the
calculateProbabilityHist function
---
 src/Utils.cpp | 63 +++++++++++++++++++--------------------------------
 test/test.cpp | 10 ++++++++
 2 files changed, 33 insertions(+), 40 deletions(-)

diff --git a/src/Utils.cpp b/src/Utils.cpp
index a46baac..4da17f0 100644
--- a/src/Utils.cpp
+++ b/src/Utils.cpp
@@ -10,23 +10,15 @@ namespace Utils {
 	using namespace std;
 
 	std::vector<std::pair<double, double>> calculateProbabilityHist(const std::vector<double>& data, int num_bins) {
-		// Determine data range
-		double min_val = 0.0;
-		double max_val = 0.0;
-		auto min_it = min_element(data.begin(), data.end());
-		if (min_it != data.end()) {
-			min_val = *min_it;
-		}
-		else {
-			cout << "Minimum value not found. Data vector has " << data.size() << " elements." << endl;
-		}
-		auto max_it = max_element(data.begin(), data.end());
-		if (max_it != data.end()) {
-			max_val = *max_it;
-		}
-		else {
-			cout << "Maximum value not found. Data vector has " << data.size() << " elements." << endl;
+		// Check for valid input data
+		if ((int)data.size() == 0) {
+			cout << "Error! Cannot calculate probability histogram because data vector is empty." << endl;
+			std::vector<std::pair<double, double>> null_output = { {0.0,0.0} };
+			return null_output;
 		}
+		// Determine data range
+		double min_val = *min_element(data.begin(), data.end());
+		double max_val = *max_element(data.begin(), data.end());
 		// Limit the number of bins to the number of data entries
 		if (num_bins > (int)data.size()) {
 			num_bins = (int)data.size();
@@ -40,23 +32,15 @@ namespace Utils {
 	}
 
 	std::vector<std::pair<double, double>> calculateProbabilityHist(const std::vector<double>& data, double bin_size) {
-		// Determine data range
-		double min_val = 0.0;
-		double max_val = 0.0;
-		auto min_it = min_element(data.begin(), data.end());
-		if (min_it != data.end()) {
-			min_val = *min_it;
-		}
-		else {
-			cout << "Minimum value not found. Data vector has " << data.size() << " elements." << endl;
-		}
-		auto max_it = max_element(data.begin(), data.end());
-		if (max_it != data.end()) {
-			max_val = *max_it;
-		}
-		else {
-			cout << "Maximum value not found. Data vector has " << data.size() << " elements." << endl;
+		// Check for valid input data
+		if ((int)data.size() == 0) {
+			cout << "Error! Cannot calculate probability histogram because data vector is empty." << endl;
+			std::vector<std::pair<double, double>> null_output = { { 0.0,0.0 } };
+			return null_output;
 		}
+		// Determine data range
+		double min_val = *min_element(data.begin(), data.end());
+		double max_val = *max_element(data.begin(), data.end());
 		// Extend the range a little bit to ensure all data fits in the range
 		min_val -= 1e-12*abs(min_val);
 		max_val += 1e-12*abs(max_val);
@@ -71,15 +55,14 @@ namespace Utils {
 	}
 
 	std::vector<std::pair<double, double>> calculateProbabilityHist(const std::vector<double>& data, const double bin_size, const int num_bins) {
-		// Determine the starting bin position
-		double min_val = 0.0;
-		auto min_it = min_element(data.begin(), data.end());
-		if (min_it != data.end()) {
-			min_val = *min_it;
-		}
-		else {
-			cout << "Minimum value not found. Data vector has " << data.size() << " elements." << endl;
+		// Check for valid input data
+		if ((int)data.size() == 0) {
+			cout << "Error! Cannot calculate probability histogram because data vector is empty." << endl;
+			std::vector<std::pair<double, double>> null_output = { { 0.0,0.0 } };
+			return null_output;
 		}
+		// Determine the starting bin position
+		double min_val = *min_element(data.begin(), data.end());
 		// Extend the range a little bit to ensure all data fits in the range
 		min_val -= 1e-12*abs(min_val);
 		// Calculate bin-centered x values
diff --git a/test/test.cpp b/test/test.cpp
index 6b5f2a1..f4792df 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -49,6 +49,16 @@ namespace UtilsTests {
 		EXPECT_NEAR(1.0 / 100.0, hist[dist2(gen)].second, 1e-4);
 		EXPECT_NEAR(1.0 / 100.0, hist[dist2(gen)].second, 1e-4);
 		EXPECT_NEAR(1.0 / 100.0, hist[dist2(gen)].second, 1e-4);
+		data.clear();
+		hist = calculateProbabilityHist(data, 10.0);
+		EXPECT_DOUBLE_EQ(0.0, hist[0].first);
+		EXPECT_DOUBLE_EQ(0.0, hist[0].second);
+		hist = calculateProbabilityHist(data, 5);
+		EXPECT_DOUBLE_EQ(0.0, hist[0].first);
+		EXPECT_DOUBLE_EQ(0.0, hist[0].second);
+		hist = calculateProbabilityHist(data, 1.0, 5);
+		EXPECT_DOUBLE_EQ(0.0, hist[0].first);
+		EXPECT_DOUBLE_EQ(0.0, hist[0].second);
 	}
 
 	TEST(UtilsTests, ExponentialDOSTests) {

From af0e0f0581cae79ecfa9d0b9173f2b6f595b440e Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Tue, 8 May 2018 14:00:53 -0400
Subject: [PATCH 10/37] Testing Update

-added more Utils and Lattice tests for better coverage
---
 test/test.cpp | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/test/test.cpp b/test/test.cpp
index f4792df..40c096b 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -59,6 +59,11 @@ namespace UtilsTests {
 		hist = calculateProbabilityHist(data, 1.0, 5);
 		EXPECT_DOUBLE_EQ(0.0, hist[0].first);
 		EXPECT_DOUBLE_EQ(0.0, hist[0].second);
+		data = {0.0, 1.0, 2.0, 3.0, 4.0};
+		hist = calculateProbabilityHist(data, 10);
+		EXPECT_EQ(5, (int)hist.size());
+		hist = calculateProbabilityHist(data, 0.1);
+		EXPECT_EQ(5, (int)hist.size());
 	}
 
 	TEST(UtilsTests, ExponentialDOSTests) {
@@ -130,6 +135,8 @@ namespace UtilsTests {
 			data_vec[i].second = 2.5*data_vec[i].first - 5.0;
 		}
 		EXPECT_NEAR(3.25, interpolateData(data_vec, 3.3), 1e-4);
+		EXPECT_DOUBLE_EQ(7.5, interpolateData(data_vec, 5));
+		EXPECT_TRUE(std::isnan(interpolateData(data_vec, 21.0)));
 	}
 
 	TEST(UtilsTests, RemoveWhitespaceTests) {
@@ -288,6 +295,7 @@ namespace LatticeTests{
 		EXPECT_EQ(50, lattice.getHeight());
 		EXPECT_DOUBLE_EQ(1.0, lattice.getUnitSize());
 		EXPECT_EQ((long int)50 * 50 * 50, lattice.getNumSites());
+		EXPECT_DOUBLE_EQ(125000e-21,lattice.getVolume());
 	}
 
 	TEST_F(LatticeTest, CalculateDestCoordsTests) {
@@ -302,6 +310,11 @@ namespace LatticeTests{
 		EXPECT_EQ(1, coords_f.x);
 		EXPECT_EQ(48, coords_f.y);
 		EXPECT_EQ(1, coords_f.z);
+		coords_i.setXYZ(1, 48, 1);
+		lattice.calculateDestinationCoords(coords_i, -2, 2, -3, coords_f);
+		EXPECT_EQ(49, coords_f.x);
+		EXPECT_EQ(0, coords_f.y);
+		EXPECT_EQ(48, coords_f.z);
 	}
 
 	TEST_F(LatticeTest, PeriodicCrossingTests) {
@@ -328,11 +341,19 @@ namespace LatticeTests{
 		params_lattice.Enable_periodic_z = true;
 		Lattice lattice2;
 		lattice2.init(params_lattice, &gen);
+		EXPECT_FALSE(lattice2.isXPeriodic());
+		EXPECT_FALSE(lattice2.isYPeriodic());
+		EXPECT_TRUE(lattice2.isZPeriodic());
 		Coords coords1{ 49, 0, 49 };
+		EXPECT_FALSE(lattice2.checkMoveValidity(coords1, 0, 0, 0));
 		EXPECT_FALSE(lattice2.checkMoveValidity(coords1, 1, 0, 0));
 		EXPECT_FALSE(lattice2.checkMoveValidity(coords1, 0, -1, 0));
 		EXPECT_TRUE(lattice2.checkMoveValidity(coords1, 0, 0, 1));
 		EXPECT_TRUE(lattice2.checkMoveValidity(coords1, -1, 1, -1));
+		params_lattice.Enable_periodic_z = false;
+		lattice2.init(params_lattice, &gen);
+		EXPECT_FALSE(lattice2.isZPeriodic());
+		EXPECT_FALSE(lattice2.checkMoveValidity(coords1, 0, 0, 1));
 	}
 
 	TEST_F(LatticeTest, RandomSiteGenTests) {
@@ -411,12 +432,16 @@ namespace LatticeTests{
 		EXPECT_FALSE(lattice.isOccupied(coords));
 	}
 
-	TEST_F(LatticeTest, SetSitePointersTests) {
+	TEST_F(LatticeTest, SiteTests) {
 		Site site;
 		vector<Site*> site_ptrs(10, &site);
 		EXPECT_FALSE(lattice.setSitePointers(site_ptrs));
 		site_ptrs.assign(50 * 50 * 50, &site);
 		EXPECT_TRUE(lattice.setSitePointers(site_ptrs));
+		Coords coords{5,6,7};
+		Site* site1 = *lattice.getSiteIt(coords);
+		Site* site2 = site_ptrs[lattice.getSiteIndex(coords)];
+		EXPECT_EQ(site1,site2);
 	}
 }
 

From f2b6ff9f5efa6e5d3ee5b679a6955e759550484b Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Tue, 8 May 2018 15:06:33 -0400
Subject: [PATCH 11/37] Testing Update

-added additional unit tests for better coverage
---
 test/test.cpp | 50 +++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 49 insertions(+), 1 deletion(-)

diff --git a/test/test.cpp b/test/test.cpp
index 40c096b..d33f59b 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -136,7 +136,10 @@ namespace UtilsTests {
 		}
 		EXPECT_NEAR(3.25, interpolateData(data_vec, 3.3), 1e-4);
 		EXPECT_DOUBLE_EQ(7.5, interpolateData(data_vec, 5));
+		// Attempt to interpolate beyond the data range
+		EXPECT_TRUE(std::isnan(interpolateData(data_vec, -1.0)));
 		EXPECT_TRUE(std::isnan(interpolateData(data_vec, 21.0)));
+		
 	}
 
 	TEST(UtilsTests, RemoveWhitespaceTests) {
@@ -146,6 +149,10 @@ namespace UtilsTests {
 		EXPECT_EQ(removeWhitespace(str), "text");
 		str = "			text ";
 		EXPECT_EQ(removeWhitespace(str), "text");
+		str = "t e	xt";
+		EXPECT_EQ(removeWhitespace(str), "text");
+		str = "text";
+		EXPECT_EQ(removeWhitespace(str), "text");
 	}
 
 	TEST(UtilsTests, ArrayStatsTests) {
@@ -323,11 +330,21 @@ namespace LatticeTests{
 		EXPECT_EQ(lattice.calculateDX(coords_i, coords_f), -50);
 		EXPECT_EQ(lattice.calculateDY(coords_i, coords_f), 0);
 		EXPECT_EQ(lattice.calculateDZ(coords_i, coords_f), 0);
+		coords_i = { 0, 49, 48 };
+		coords_f = { 49, 49, 49 };
+		EXPECT_EQ(lattice.calculateDX(coords_i, coords_f), 50);
+		EXPECT_EQ(lattice.calculateDY(coords_i, coords_f), 0);
+		EXPECT_EQ(lattice.calculateDZ(coords_i, coords_f), 0);
 		coords_i.setXYZ(0, 0, 49);
 		coords_f.setXYZ(1, 49, 0);
 		EXPECT_EQ(lattice.calculateDX(coords_i, coords_f), 0);
 		EXPECT_EQ(lattice.calculateDY(coords_i, coords_f), 50);
 		EXPECT_EQ(lattice.calculateDZ(coords_i, coords_f), -50);
+		coords_i = {1, 49, 0};
+		coords_f = {0, 0, 49};
+		EXPECT_EQ(lattice.calculateDX(coords_i, coords_f), 0);
+		EXPECT_EQ(lattice.calculateDY(coords_i, coords_f), -50);
+		EXPECT_EQ(lattice.calculateDZ(coords_i, coords_f), 50);
 		coords_i.setXYZ(4, 5, 6);
 		coords_f.setXYZ(3, 6, 5);
 		EXPECT_EQ(lattice.calculateDX(coords_i, coords_f), 0);
@@ -442,6 +459,17 @@ namespace LatticeTests{
 		Site* site1 = *lattice.getSiteIt(coords);
 		Site* site2 = site_ptrs[lattice.getSiteIndex(coords)];
 		EXPECT_EQ(site1,site2);
+		// Check for sites and indices outside the lattice
+		coords = {0, 60, 0};
+		EXPECT_THROW(lattice.getSiteIndex(coords),out_of_range);
+		EXPECT_THROW(lattice.getSiteCoords(150000),out_of_range);
+		// Check site object assignment and clearing
+		Object object;
+		site.setObjectPtr(&object);
+		EXPECT_TRUE(site.isOccupied());
+		EXPECT_EQ(&object,site.getObjectPtr());
+		site.clearOccupancy();
+		EXPECT_FALSE(site.isOccupied());
 	}
 }
 
@@ -510,9 +538,25 @@ namespace EventTests {
 
 namespace ObjectTests {
 	
+	TEST(ObjectTests, GeneralObjectTests) {
+		// Assume object is created in a 50 x 50 x 50 lattice
+		Coords coords = {0,0,0};
+		Object object1(0.0, 1, coords);
+		EXPECT_EQ("Object",object1.getObjectType());
+		EXPECT_EQ(1,object1.getTag());
+		EXPECT_EQ(coords,object1.getCoords());
+		EXPECT_DOUBLE_EQ(0.0,object1.getCreationTime());
+		// Object-Event tests
+		Event event;
+		list<Event*> event_ptrs;
+		event_ptrs.push_back(&event);
+		object1.setEventIt(event_ptrs.begin());
+		EXPECT_EQ(&event,*(object1.getEventIt()));
+	}
+	
 	TEST(ObjectTests, CalculateDisplacementTests) {
 		// Assume object is created in a 50 x 50 x 50 lattice
-		Object object1(0, 1, { 0,0,0 });
+		Object object1(0.0, 1, { 0,0,0 });
 		object1.setCoords({ 0,0,5 });
 		EXPECT_DOUBLE_EQ(5.0, object1.calculateDisplacement());
 		object1.setCoords({ 0,0,49 });
@@ -525,7 +569,11 @@ namespace ObjectTests {
 		object1.setCoords({ 49,0,49 });
 		object1.incrementDY(50);
 		EXPECT_DOUBLE_EQ(sqrt(2), object1.calculateDisplacement());
+		object1.resetInitialCoords({5,5,5});
+		object1.setCoords({ 4,4,4 });
+		EXPECT_DOUBLE_EQ(sqrt(3), object1.calculateDisplacement());
 	}
+	
 }
 
 

From fab49c50cbec6fbbe78dd1a9ca988509c965895c Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Tue, 8 May 2018 15:32:58 -0400
Subject: [PATCH 12/37] Utils Update

-added a basic constructor to the Coords class of the form coords(x,y,z)
---
 src/Utils.cpp |  2 +-
 src/Utils.h   | 17 +++++++++++++++--
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/Utils.cpp b/src/Utils.cpp
index 4da17f0..775cfba 100644
--- a/src/Utils.cpp
+++ b/src/Utils.cpp
@@ -142,7 +142,7 @@ namespace Utils {
 			if (data[i-1].first < x_val && data[i].first > x_val) {
 				return data[i - 1].second + ((data[i].second - data[i - 1].second) / (data[i].first - data[i - 1].first))*(x_val - data[i - 1].first);
 			}
-			if (abs(data[i].first - x_val) < 1e-6) {
+			if (abs(data[i].first - x_val) < 1e-12) {
 				return data[i].second;
 			}
 		}
diff --git a/src/Utils.h b/src/Utils.h
index a87d8f5..6001bae 100644
--- a/src/Utils.h
+++ b/src/Utils.h
@@ -30,6 +30,19 @@ struct Coords{
 	//! The z Cartesian coordinate.
     int z;
 
+	//! Default constructor that creates an empty Coords object.
+	Coords(){}
+
+	//! \brief Constructor that creates a Coords object with the x,y,z coordinates set using the input values xval, yval, and zval.
+	//! \param xval is the input x value.
+	//! \param yval is the input y value.
+	//! \param zval is the input z value.
+	Coords(const int xval, const int yval, const int zval) {
+		x = xval;
+		y = yval;
+		z = zval;
+	}
+
 	//! \brief Sets the x,y,z coordinates using the input values xval, yval, and zval.
 	//! \param xval is the input x value.
 	//! \param yval is the input y value.
@@ -154,7 +167,7 @@ namespace Utils {
 
 	//! \brief Uses MPI to gather vectors from separate processors to build one big vector containing all of the data.
 	//! \details Each processor calls this function and sends an input vector.  Upon function return, processor 0
-	//! receives the large data vector and all of the othe rprocessors receive an empty vector.
+	//! receives the large data vector and all of the other processors receive an empty vector.
 	//! \param input_vector is the input data from the processor calling the function.
 	//! \return A vector that is a concatenation of all input vectors from each processor, when called on processor 0.
 	//! \return An empty vector when called on other processors.
@@ -162,7 +175,7 @@ namespace Utils {
 
 	//! \brief Uses MPI to gather vectors from separate processors to build one big vector containing all of the data.
 	//! \details Each processor calls this function and sends an input vector.  Upon function return, processor 0
-	//! receives the large data vector and all of the othe rprocessors receive an empty vector.
+	//! receives the large data vector and all of the other processors receive an empty vector.
 	//! \param input_vector is the input data from the processor calling the function.
 	//! \return A vector that is a concatenation of all input vectors from each processor, when called on processor 0.
 	//! \return An empty vector when called on other processors.

From ed8ec6dc711790c15d27f10ff7d51f994cec5b2a Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Tue, 8 May 2018 15:33:27 -0400
Subject: [PATCH 13/37] Testing Update

-added more Event class tests to increase test coverage
---
 test/test.cpp | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/test/test.cpp b/test/test.cpp
index d33f59b..500ab14 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -499,6 +499,24 @@ namespace EventTests {
 			test_sim.init(params_base, 0);
 		}
 	};
+	
+	TEST_F(EventTest, GeneralEventTests){
+		Event event(&test_sim);
+		EXPECT_EQ("Event",event.getEventType());
+		Coords coords1(0,0,0);
+		Object object1(0.0, 1, coords1);
+		event.setObjectPtr(&object1);
+		EXPECT_EQ(&object1,event.getObjectPtr());
+		Coords coords2(1,0,0);
+		Object object2(0.0, 2, coords2);
+		event.setObjectTargetPtr(&object2);
+		EXPECT_EQ(&object2,event.getObjectTargetPtr());
+		event.setDestCoords(coords2);
+		EXPECT_EQ(coords2,event.getDestCoords());
+		EXPECT_FALSE(event.setExecutionTime(-1.0));
+		EXPECT_TRUE(event.setExecutionTime(1.0));
+		EXPECT_DOUBLE_EQ(1.0,event.getExecutionTime());
+	}
 
 	TEST_F(EventTest, CalculateExecutionTimeTests) {
 		Event event(&test_sim);

From d523f8e2c91cdbe5156d848f5d430c30d1481554 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Tue, 8 May 2018 18:29:54 -0400
Subject: [PATCH 14/37] Testing Update

-updated TestSim dervied Simulation class for creating a testable object
-added a number of unit tests for the Simulation class
---
 test/test.cpp | 118 ++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 115 insertions(+), 3 deletions(-)

diff --git a/test/test.cpp b/test/test.cpp
index 500ab14..c210f2d 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -14,10 +14,123 @@ using namespace Utils;
 // Simple derived Simulation class
 class TestSim : public Simulation {
 public:
-	bool checkFinished() const { return false; };
-	bool executeNextEvent() { return false; };
+	vector<Object> objects;
+	vector<Event> events;
+	vector<Site> sites;
+
+	bool init(const Parameters_Simulation& params, const int id) {
+		// Initialize Simulation base class
+		Simulation::init(params, id);
+		// Initialize Sites
+		Site site;
+		sites.assign(lattice.getNumSites(), site);
+		vector<Site*> site_ptrs;
+		for (auto& item : sites) {
+			site_ptrs.push_back(&item);
+		}
+		lattice.setSitePointers(site_ptrs);
+		// Perform test initialization
+		// Construct and add initial object
+		Coords coords1(0, 0, 0);
+		Object object1(0.0, 1, coords1);
+		objects.push_back(object1);
+		addObject(&objects[0]);
+		// Construct and add event for the object
+		Event event1(this);
+		event1.setObjectPtr(&objects[0]);
+		Coords coords2(1, 0, 0);
+		event1.setDestCoords(coords2);
+		event1.calculateExecutionTime(1.0);
+		events.push_back(event1);
+		setObjectEvent(&objects[0], &events[0]);
+		return true;
+	}
+
+	void calculateNextEvent(Object* object_ptr) {
+		Event* event_ptr = *(object_ptr->getEventIt());
+		Coords coords_i = object_ptr->getCoords();
+		Coords coords_f;
+		lattice.calculateDestinationCoords(coords_i, 0, 10, 0, coords_f);
+		event_ptr->setDestCoords(coords_f);
+		event_ptr->calculateExecutionTime(1.0);
+	}
+
+	bool checkFinished() const {
+		return (getN_events_executed() == 8);
+	}
+
+	bool executeNextEvent() {
+		Event* event_ptr = *chooseNextEvent();
+		setTime(event_ptr->getExecutionTime());
+		Coords coords_i = (*(event_ptr->getObjectPtr())).getCoords();
+		Coords coords_f = event_ptr->getDestCoords();
+		moveObject(event_ptr->getObjectPtr(), event_ptr->getDestCoords());
+		auto object_vec = findRecalcObjects(coords_i, coords_f);
+		for (auto item : object_vec) {
+			calculateNextEvent(item);
+		}
+		return true;
+	}
+	
 };
 
+namespace SimulationTests {
+
+	class SimulationTest : public ::testing::Test {
+	protected:
+		Parameters_Simulation params_base;
+		TestSim sim;
+		void SetUp() {
+			{
+				params_base.Enable_logging = false;
+				params_base.Enable_periodic_x = true;
+				params_base.Enable_periodic_y = true;
+				params_base.Enable_periodic_z = true;
+				params_base.Length = 50;
+				params_base.Width = 50;
+				params_base.Height = 50;
+				params_base.Unit_size = 1.0;
+				params_base.Temperature = 300;
+				params_base.Enable_FRM = false;
+				params_base.Enable_selective_recalc = true;
+				params_base.Recalc_cutoff = 3;
+				params_base.Enable_full_recalc = false;
+			}
+			// Initialize TestSim object
+			sim.init(params_base, 0);
+			sim.setGeneratorSeed(0);
+		}
+	};
+
+	TEST_F(SimulationTest, SetupTests) {
+		EXPECT_EQ(0, sim.getId());
+		EXPECT_FALSE(sim.isLoggingEnabled());
+		EXPECT_DOUBLE_EQ(0.0, sim.getTime());
+		EXPECT_EQ(300, sim.getTemp());
+		EXPECT_DOUBLE_EQ(125000e-21, sim.getVolume());
+	}
+
+	TEST_F(SimulationTest, EventExecutionTests) {
+		Coords coords(0, 0, 0);
+		EXPECT_EQ(coords, sim.objects[0].getCoords());
+		EXPECT_EQ(1, sim.getN_events());
+		EXPECT_TRUE(sim.executeNextEvent());
+		coords.setXYZ(1, 0, 0);
+		EXPECT_EQ(coords, sim.objects[0].getCoords());
+		EXPECT_EQ(2, sim.getN_events_executed());
+		EXPECT_FALSE(sim.checkFinished());
+		while (!sim.checkFinished()) {
+			EXPECT_TRUE(sim.executeNextEvent());
+		}
+		EXPECT_EQ(8, sim.getN_events_executed());
+		Coords coords_f(1, 10, 0);
+		EXPECT_EQ(coords_f.x, sim.objects[0].getCoords().x);
+		EXPECT_EQ(coords_f.y, sim.objects[0].getCoords().y);
+		EXPECT_EQ(coords_f.z, sim.objects[0].getCoords().z);
+	}
+
+}
+
 namespace UtilsTests {
 
 	TEST(UtilsTests, CoordsTests) {
@@ -594,7 +707,6 @@ namespace ObjectTests {
 	
 }
 
-
 int main(int argc, char **argv) {
 	::testing::InitGoogleTest(&argc, argv);
 	return RUN_ALL_TESTS();

From f1fe19dd8ae404bc6cb99b0df26a5a306f080426 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Wed, 9 May 2018 09:39:40 -0400
Subject: [PATCH 15/37] Coveralls Testing Update

-updated travis yml file so that each env variable set has a designated
build target and added a separate test item for doing test coverage
assessment, which should save testing time on the rest of the builds
-updated makefile to have separate test and test_coverage build targets
with different compiler flags
---
 .travis.yml | 43 ++++++++++++++++++++++---------------------
 makefile    | 11 +++++------
 2 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 03f4a5f..70c2278 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -13,34 +13,35 @@ compiler:
     - gcc
     
 env:
-    - COMPILER_OPTIONS="VERSION=4.7 && MPI=mpich2"
-    - COMPILER_OPTIONS="VERSION=4.7 && MPI=openmpi"
-    - COMPILER_OPTIONS="VERSION=4.8 && MPI=mpich2"
-    - COMPILER_OPTIONS="VERSION=4.8 && MPI=openmpi"
-    - COMPILER_OPTIONS="VERSION=4.9 && MPI=mpich2"
-    - COMPILER_OPTIONS="VERSION=4.9 && MPI=openmpi"
-    - COMPILER_OPTIONS="VERSION=5 && MPI=mpich2"
-    - COMPILER_OPTIONS="VERSION=5 && MPI=openmpi"
-    - COMPILER_OPTIONS="VERSION=6 && MPI=mpich2"
-    - COMPILER_OPTIONS="VERSION=6 && MPI=openmpi"
-    - COMPILER_OPTIONS="VERSION=7 && MPI=mpich2"
-    - COMPILER_OPTIONS="VERSION=7 && MPI=openmpi"
-    - COMPILER_OPTIONS="VERSION=8 && MPI=mpich2"
-    - COMPILER_OPTIONS="VERSION=8 && MPI=openmpi"
+    - OPTIONS="GCC_VERSION=5 && MPI=openmpi && TARGET=test_coverage"
+    - OPTIONS="GCC_VERSION=4.7 && MPI=mpich2 && TARGET=test"
+    - OPTIONS="GCC_VERSION=4.7 && MPI=openmpi && TARGET=test"
+    - OPTIONS="GCC_VERSION=4.8 && MPI=mpich2 && TARGET=test"
+    - OPTIONS="GCC_VERSION=4.8 && MPI=openmpi && TARGET=test"
+    - OPTIONS="GCC_VERSION=4.9 && MPI=mpich2 && TARGET=test"
+    - OPTIONS="GCC_VERSION=4.9 && MPI=openmpi && TARGET=test"
+    - OPTIONS="GCC_VERSION=5 && MPI=mpich2 && TARGET=test"
+    - OPTIONS="GCC_VERSION=5 && MPI=openmpi && TARGET=test"
+    - OPTIONS="GCC_VERSION=6 && MPI=mpich2 && TARGET=test"
+    - OPTIONS="GCC_VERSION=6 && MPI=openmpi && TARGET=test"
+    - OPTIONS="GCC_VERSION=7 && MPI=mpich2 && TARGET=test"
+    - OPTIONS="GCC_VERSION=7 && MPI=openmpi && TARGET=test"
+    - OPTIONS="GCC_VERSION=8 && MPI=mpich2 && TARGET=test"
+    - OPTIONS="GCC_VERSION=8 && MPI=openmpi && TARGET=test"
          
 before_install:
-    - eval "${COMPILER_OPTIONS}"
+    - eval "${OPTIONS}"
     - sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
     - sudo apt-get update -qq
-    - sudo apt-get install -qq gcc-$VERSION g++-$VERSION -y
-    - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-$VERSION 60 --slave /usr/bin/g++ g++ /usr/bin/g++-$VERSION
+    - sudo apt-get install -qq gcc-$GCC_VERSION g++-$GCC_VERSION -y
+    - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-$GCC_VERSION 60 --slave /usr/bin/g++ g++ /usr/bin/g++-$GCC_VERSION
     - sudo update-alternatives --config gcc
     - gcc --version
     - if [[ "$MPI" = mpich2 ]]; then sudo apt-get -y install -qq mpich2 libmpich2-dev; fi
     - if [[ "$MPI" = openmpi ]]; then sudo apt-get -y install -qq openmpi-bin libopenmpi-dev; fi
-    - pip install --user cpp-coveralls
+    - if [[ "$TARGET" = test_coverage ]]; then pip install --user cpp-coveralls; fi
     
 script:
-    - make -j10 test && travis_wait ./test/KMC_Lattice_tests.exe
-    - make -j10 test_mpi && travis_wait mpiexec -n 4 ./test/KMC_Lattice_MPI_tests.exe
-    - coveralls --include src --exclude "googletest/*" --gcov-options '\-lp'
+    - make -j10 $TARGET && travis_wait ./test/KMC_Lattice_tests.exe && travis_wait mpiexec -n 4 ./test/KMC_Lattice_MPI_tests.exe
+    - if [[ "$TARGET" = test_coverage ]]; then coveralls --include src --exclude "googletest/*" --gcov-options '\-lp'; fi
+    - 
diff --git a/makefile b/makefile
index 18c810d..6e46b0a 100644
--- a/makefile
+++ b/makefile
@@ -56,8 +56,10 @@ ifeq ($(lastword $(subst /, ,$(CXX))),pgc++)
 	GTEST_FLAGS = -I$(GTEST_DIR)/include
 endif
 
-test : FLAGS = -fprofile-arcs -ftest-coverage -std=c++11 -Wall -Wextra -I. -Isrc
-test : test/KMC_Lattice_tests.exe	
+test_coverage : FLAGS = -fprofile-arcs -ftest-coverage -std=c++11 -Wall -Wextra -I. -Isrc
+test_coverage : test/KMC_Lattice_tests.exe test/KMC_Lattice_MPI_tests.exe
+
+test : test/KMC_Lattice_tests.exe test/KMC_Lattice_MPI_tests.exe
 	
 test/KMC_Lattice_tests.exe : test/test.o test/gtest-all.o $(OBJS)
 	mpicxx $(GTEST_FLAGS) $(FLAGS) -lpthread $^ -o $@
@@ -68,9 +70,6 @@ test/gtest-all.o : $(GTEST_SRCS_)
 test/test.o : test/test.cpp $(GTEST_HEADERS) $(OBJS)
 	mpicxx $(GTEST_FLAGS) $(FLAGS) -c $< -o $@
 
-test_mpi : FLAGS = -fprofile-arcs -ftest-coverage -std=c++11 -Wall -Wextra -I. -Isrc
-test_mpi : test/KMC_Lattice_MPI_tests.exe
-
 test/KMC_Lattice_MPI_tests.exe : test/test_mpi.o test/gtest-all.o $(OBJS)
 	mpicxx $(GTEST_FLAGS) $(FLAGS) -lpthread $^ -o $@
 
@@ -78,4 +77,4 @@ test/test_mpi.o : test/test_mpi.cpp $(GTEST_HEADERS) $(OBJS)
 	mpicxx $(GTEST_FLAGS) $(FLAGS) -c $< -o $@
 	
 clean:
-	-rm src/*.o src/*.gcno* src/*.gcda KMC_Lattice/*.o KMC_Lattice/*.gcno* KMC_Lattice/*.gcda testing/*.o testing/*.gcno* testing/*.gcda *~ Excimontec.exe testing/*.o testing/Excimontec_tests.exe testing/Excimontec_mpi_tests.exe
+	-rm src/*.o src/*.gcno* src/*.gcda test/*.o test/*.gcno* test/*.gcda *~ libKMC.a test/KMC_Lattice_tests.exe test/KMC_Lattice_MPI_tests.exe

From 85990e11a80ed7c22512a9bbb6b2029de68aea3e Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Wed, 9 May 2018 10:04:46 -0400
Subject: [PATCH 16/37] Travis CI Testing Update

-removed unneeded line in travis yml fiel
---
 .travis.yml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 70c2278..528b8a8 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -44,4 +44,3 @@ before_install:
 script:
     - make -j10 $TARGET && travis_wait ./test/KMC_Lattice_tests.exe && travis_wait mpiexec -n 4 ./test/KMC_Lattice_MPI_tests.exe
     - if [[ "$TARGET" = test_coverage ]]; then coveralls --include src --exclude "googletest/*" --gcov-options '\-lp'; fi
-    - 

From c0a9ed257ffaaebb7d27b3343170dc95d88d5b4b Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Wed, 9 May 2018 13:41:45 -0400
Subject: [PATCH 17/37] Simulation Clas Minor Update

-added public getN_objects_created function to allow more information to
be gathered about the simulation progress
-refactored chooseNextEvent fucntion to be more concise
---
 src/Simulation.cpp | 16 +++++++---------
 src/Simulation.h   |  5 ++++-
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/Simulation.cpp b/src/Simulation.cpp
index 7b679f7..b14c329 100644
--- a/src/Simulation.cpp
+++ b/src/Simulation.cpp
@@ -65,15 +65,9 @@ void Simulation::addObject(Object* object_ptr) {
 }
 
 list<Event*>::const_iterator Simulation::chooseNextEvent() {
-	auto event_target_it = event_ptrs.begin();
-	if (event_ptrs.size() > 1) {
-		for (auto it = ++event_ptrs.begin(); it != event_ptrs.end(); ++it) {
-			if ((*it) != nullptr && ((*event_target_it) == nullptr || ((*it)->getExecutionTime() < (*event_target_it)->getExecutionTime()))) {
-				event_target_it = it;
-			}
-		}
-	}
-	return event_target_it;
+	return min_element(event_ptrs.begin(), event_ptrs.end(), [](Event* a, Event* b) {
+		return (a != nullptr && b != nullptr ) && (a->getExecutionTime() < b->getExecutionTime()); 
+	});
 }
 
 vector<Object*> Simulation::findRecalcObjects(const Coords& coords_start, const Coords& coords_dest) const {
@@ -163,6 +157,10 @@ long int Simulation::getN_events_executed() const {
 	return N_events_executed;
 }
 
+long int Simulation::getN_objects_created() const {
+	return N_objects_created;
+}
+
 int Simulation::getTemp() const {
 	return temperature;
 }
diff --git a/src/Simulation.h b/src/Simulation.h
index 6ad0cfc..9942a7b 100644
--- a/src/Simulation.h
+++ b/src/Simulation.h
@@ -99,6 +99,9 @@ class Simulation{
 		//! Gets the number of events that have been executed in the simulation.
         long int getN_events_executed() const;
 
+		//! Gets the number of objects that have been created in the simulation.
+		long int getN_objects_created() const;
+
 		//! \brief Gets the processor ID number for the processor that is running the simulation.
 		//! \details This is primarly used with MPI to differentiate between different simualtions running on 
 		//! different cores.
@@ -214,7 +217,7 @@ class Simulation{
 		std::list<Object*> object_ptrs;
 		std::list<Event*> event_ptrs;
         // Counters
-        double time_sim = 0;
+        double time_sim = 0.0;
         long int N_objects_created = 0;
         long int N_events_executed = 0;
         // Functions

From 4ff7ab2bc7bd879ff40d5ecb284feef20c05d5a0 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Wed, 9 May 2018 13:43:34 -0400
Subject: [PATCH 18/37] Simulation Class Testing Update

-expanded the TestSim class to contain definitions of serveral derived
Event classes and to perform a simple object creation and diffusion
simulation with greater code coverage that can be tested
---
 test/test.cpp | 149 ++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 113 insertions(+), 36 deletions(-)

diff --git a/test/test.cpp b/test/test.cpp
index c210f2d..e0e9750 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -14,9 +14,33 @@ using namespace Utils;
 // Simple derived Simulation class
 class TestSim : public Simulation {
 public:
-	vector<Object> objects;
-	vector<Event> events;
-	vector<Site> sites;
+	class CreationEvent : public Event {
+	public:
+		CreationEvent() : Event() {}
+		CreationEvent(Simulation* simulation_ptr) : Event(simulation_ptr) {}
+		string getEventType() const { return "Creation"; }
+	};
+	class MoveEvent : public Event {
+	public:
+		MoveEvent() : Event() {}
+		MoveEvent(Simulation* simulation_ptr) : Event(simulation_ptr) {}
+		string getEventType() const { return "Move"; }
+	};
+	class TerminationEvent : public Event {
+	public:
+		TerminationEvent() : Event() {}
+		TerminationEvent(Simulation* simulation_ptr) : Event(simulation_ptr) {}
+		string getEventType() const { return "Termination"; }
+	};
+
+	// Data members
+	list<Object> objects;
+	list<Site> sites;
+	CreationEvent event_creation;
+	list<MoveEvent> events_move;
+	list<TerminationEvent> events_termination;
+	int N_move_events = 0;
+	int N_termination_events = 0;
 
 	bool init(const Parameters_Simulation& params, const int id) {
 		// Initialize Simulation base class
@@ -30,47 +54,104 @@ class TestSim : public Simulation {
 		}
 		lattice.setSitePointers(site_ptrs);
 		// Perform test initialization
-		// Construct and add initial object
-		Coords coords1(0, 0, 0);
-		Object object1(0.0, 1, coords1);
-		objects.push_back(object1);
-		addObject(&objects[0]);
-		// Construct and add event for the object
-		Event event1(this);
-		event1.setObjectPtr(&objects[0]);
-		Coords coords2(1, 0, 0);
-		event1.setDestCoords(coords2);
-		event1.calculateExecutionTime(1.0);
-		events.push_back(event1);
-		setObjectEvent(&objects[0], &events[0]);
+		CreationEvent event_creation_new(this);
+		event_creation = event_creation_new;
+		event_creation.setDestCoords(lattice.generateRandomCoords());
+		event_creation.calculateExecutionTime(1.0);
+		addEvent(&event_creation);
 		return true;
 	}
 
 	void calculateNextEvent(Object* object_ptr) {
-		Event* event_ptr = *(object_ptr->getEventIt());
+		auto move_event_it = find_if(events_move.begin(), events_move.end(), [object_ptr](MoveEvent& a) { return a.getObjectPtr() == object_ptr; });
+		auto termination_event_it = find_if(events_termination.begin(), events_termination.end(), [object_ptr](TerminationEvent& a) { return a.getObjectPtr() == object_ptr; });
+		// Calculate move events
+		move_event_it->calculateExecutionTime(100);
 		Coords coords_i = object_ptr->getCoords();
 		Coords coords_f;
-		lattice.calculateDestinationCoords(coords_i, 0, 10, 0, coords_f);
-		event_ptr->setDestCoords(coords_f);
-		event_ptr->calculateExecutionTime(1.0);
+		lattice.calculateDestinationCoords(coords_i, 1, 0, 0, coords_f);
+		move_event_it->setDestCoords(coords_f);
+		// Calculate termination event
+		termination_event_it->setDestCoords(coords_i);
+		termination_event_it->calculateExecutionTime(10);
+		// Select fastest event
+		if (move_event_it->getExecutionTime() < termination_event_it->getExecutionTime()) {
+			setObjectEvent(object_ptr, &(*move_event_it));
+		}
+		else {
+			setObjectEvent(object_ptr, &(*termination_event_it));
+		}
 	}
 
 	bool checkFinished() const {
-		return (getN_events_executed() == 8);
+		return (getN_objects_created() == 5);
+	}
+
+	void executeCreationEvent(const std::list<Event*>::const_iterator event_it) {
+		Event* event_ptr = *event_it;
+		Coords coords_dest = event_ptr->getDestCoords();
+		Object object(event_ptr->getExecutionTime(),getN_objects_created()+1,coords_dest);
+		objects.push_back(object);
+		addObject(&objects.back());
+		Simulation* sim_ptr = this;
+		MoveEvent event1(sim_ptr);
+		event1.setObjectPtr(&objects.back());
+		events_move.push_back(event1);
+		TerminationEvent event2(sim_ptr);
+		event2.setObjectPtr(&objects.back());
+		events_termination.push_back(event2);
+		// Calculate next creation event
+		event_creation.setDestCoords(lattice.generateRandomCoords());
+		event_creation.calculateExecutionTime(1.0);
+	}
+
+	void executeMoveEvent(const std::list<Event*>::const_iterator event_it) {
+		Event* event_ptr = *event_it;
+		moveObject(event_ptr->getObjectPtr(), event_ptr->getDestCoords());
+		N_move_events++;
 	}
 
 	bool executeNextEvent() {
-		Event* event_ptr = *chooseNextEvent();
-		setTime(event_ptr->getExecutionTime());
-		Coords coords_i = (*(event_ptr->getObjectPtr())).getCoords();
+		auto event_it = chooseNextEvent();
+		Event* event_ptr = *event_it;
+		string event_type = event_ptr->getEventType();
+		Coords coords_i;
 		Coords coords_f = event_ptr->getDestCoords();
-		moveObject(event_ptr->getObjectPtr(), event_ptr->getDestCoords());
+		setTime(event_ptr->getExecutionTime());
+		if (event_type.compare("Creation")==0) {
+			executeCreationEvent(event_it);
+			coords_i = coords_f;
+		}
+		else {
+			coords_i = event_ptr->getObjectPtr()->getCoords();
+			if (event_type.compare("Move")==0) {
+				executeMoveEvent(event_it);
+			}
+			else if (event_type.compare("Termination")==0) {
+				executeTerminationEvent(event_it);
+			}
+			else {
+				return false;
+			}
+		}
 		auto object_vec = findRecalcObjects(coords_i, coords_f);
 		for (auto item : object_vec) {
 			calculateNextEvent(item);
 		}
 		return true;
 	}
+
+	void executeTerminationEvent(const std::list<Event*>::const_iterator event_it) {
+		Object* object_ptr = (*event_it)->getObjectPtr();
+		// Remove object from Simulation class
+		removeObject(object_ptr);
+		// Remove local events
+		auto move_event_it = find_if(events_move.begin(), events_move.end(), [object_ptr](MoveEvent& a) { return a.getObjectPtr() == object_ptr; });
+		events_move.erase(move_event_it);
+		auto termination_event_it = find_if(events_termination.begin(), events_termination.end(), [object_ptr](TerminationEvent& a) { return a.getObjectPtr() == object_ptr; });
+		events_termination.erase(termination_event_it);
+		N_termination_events++;
+	}
 	
 };
 
@@ -111,22 +192,18 @@ namespace SimulationTests {
 	}
 
 	TEST_F(SimulationTest, EventExecutionTests) {
-		Coords coords(0, 0, 0);
-		EXPECT_EQ(coords, sim.objects[0].getCoords());
+		EXPECT_EQ(0, (int)sim.objects.size());
 		EXPECT_EQ(1, sim.getN_events());
 		EXPECT_TRUE(sim.executeNextEvent());
-		coords.setXYZ(1, 0, 0);
-		EXPECT_EQ(coords, sim.objects[0].getCoords());
-		EXPECT_EQ(2, sim.getN_events_executed());
+		EXPECT_EQ(1, (int)sim.objects.size());
+		EXPECT_EQ(1, sim.objects.front().getTag());
+		EXPECT_EQ(2, sim.getN_events());
+		EXPECT_EQ(1, sim.getN_events_executed());
 		EXPECT_FALSE(sim.checkFinished());
 		while (!sim.checkFinished()) {
-			EXPECT_TRUE(sim.executeNextEvent());
+			sim.executeNextEvent();
 		}
-		EXPECT_EQ(8, sim.getN_events_executed());
-		Coords coords_f(1, 10, 0);
-		EXPECT_EQ(coords_f.x, sim.objects[0].getCoords().x);
-		EXPECT_EQ(coords_f.y, sim.objects[0].getCoords().y);
-		EXPECT_EQ(coords_f.z, sim.objects[0].getCoords().z);
+
 	}
 
 }

From 565029c7dca20c3b93f963f55ce83b4b5e26e4bb Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Wed, 9 May 2018 14:59:46 -0400
Subject: [PATCH 19/37] Simulation Class Testing Update

-updated Simulation class test to run a small particle diffusion test
and added a test to check the average displacement calculated by each of
the KMC algorithms
---
 test/test.cpp | 75 ++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 71 insertions(+), 4 deletions(-)

diff --git a/test/test.cpp b/test/test.cpp
index e0e9750..59c1e34 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -39,8 +39,11 @@ class TestSim : public Simulation {
 	CreationEvent event_creation;
 	list<MoveEvent> events_move;
 	list<TerminationEvent> events_termination;
+	Event event_previous;
+	string event_previous_type;
 	int N_move_events = 0;
 	int N_termination_events = 0;
+	vector<double> displacement_data;
 
 	bool init(const Parameters_Simulation& params, const int id) {
 		// Initialize Simulation base class
@@ -69,7 +72,33 @@ class TestSim : public Simulation {
 		move_event_it->calculateExecutionTime(100);
 		Coords coords_i = object_ptr->getCoords();
 		Coords coords_f;
-		lattice.calculateDestinationCoords(coords_i, 1, 0, 0, coords_f);
+		int i = 0, j = 0, k = 0;
+		uniform_int_distribution<> dist(0, 5);
+		int rand_num = dist(generator);
+		switch (rand_num) {
+		case 0:
+			i = -1;
+			break;
+		case 1:
+			i = 1;
+			break;
+		case 2:
+			j = -1;
+			break;
+		case 3:
+			j = 1;
+			break;
+		case 4:
+			k = -1;
+			break;
+		case 5:
+			k = 1;
+			break;
+		default:
+			i = 1;
+			break;
+		}
+		lattice.calculateDestinationCoords(coords_i, i, j, k, coords_f);
 		move_event_it->setDestCoords(coords_f);
 		// Calculate termination event
 		termination_event_it->setDestCoords(coords_i);
@@ -84,7 +113,7 @@ class TestSim : public Simulation {
 	}
 
 	bool checkFinished() const {
-		return (getN_objects_created() == 5);
+		return (N_termination_events == 100000);
 	}
 
 	void executeCreationEvent(const std::list<Event*>::const_iterator event_it) {
@@ -115,6 +144,8 @@ class TestSim : public Simulation {
 		auto event_it = chooseNextEvent();
 		Event* event_ptr = *event_it;
 		string event_type = event_ptr->getEventType();
+		event_previous = *event_ptr;
+		event_previous_type = event_type;
 		Coords coords_i;
 		Coords coords_f = event_ptr->getDestCoords();
 		setTime(event_ptr->getExecutionTime());
@@ -128,6 +159,8 @@ class TestSim : public Simulation {
 				executeMoveEvent(event_it);
 			}
 			else if (event_type.compare("Termination")==0) {
+				Object* object_ptr = (*event_it)->getObjectPtr();
+				displacement_data.push_back(object_ptr->calculateDisplacement());
 				executeTerminationEvent(event_it);
 			}
 			else {
@@ -152,6 +185,14 @@ class TestSim : public Simulation {
 		events_termination.erase(termination_event_it);
 		N_termination_events++;
 	}
+
+	vector<Object*> getAllObjectPtrs() const {
+		return getAllObjectPtrs();
+	}
+
+	vector<Event*> getAllEventPtrs() const {
+		return getAllEventPtrs();
+	}
 	
 };
 
@@ -200,10 +241,36 @@ namespace SimulationTests {
 		EXPECT_EQ(2, sim.getN_events());
 		EXPECT_EQ(1, sim.getN_events_executed());
 		EXPECT_FALSE(sim.checkFinished());
+	}
+
+	TEST_F(SimulationTest, KMCAlgorithmTests) {
 		while (!sim.checkFinished()) {
-			sim.executeNextEvent();
+			EXPECT_TRUE(sim.executeNextEvent());
 		}
-
+		EXPECT_EQ(100000, sim.getN_objects_created());
+		double displacement = vector_avg(sim.displacement_data);
+		TestSim sim2;
+		params_base.Enable_FRM = true;
+		params_base.Enable_selective_recalc = false;
+		params_base.Enable_full_recalc = false;
+		sim2.init(params_base, 0);
+		while (!sim2.checkFinished()) {
+			EXPECT_TRUE(sim2.executeNextEvent());
+		}
+		EXPECT_EQ(100000, sim2.getN_objects_created());
+		double displacement2 = vector_avg(sim2.displacement_data);
+		EXPECT_NEAR(displacement, displacement2, 1e-2);
+		TestSim sim3;
+		params_base.Enable_FRM = false;
+		params_base.Enable_selective_recalc = false;
+		params_base.Enable_full_recalc = true;
+		sim3.init(params_base, 0);
+		while (!sim3.checkFinished()) {
+			EXPECT_TRUE(sim3.executeNextEvent());
+		}
+		EXPECT_EQ(100000, sim3.getN_objects_created());
+		double displacement3 = vector_avg(sim3.displacement_data);
+		EXPECT_NEAR(displacement, displacement3, 1e-2);
 	}
 
 }

From a97b8c8dc1326196ffbed3229b1a119358de32b1 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Wed, 9 May 2018 15:30:05 -0400
Subject: [PATCH 20/37] Simulation Class Testing Update

-updated simulation termination condition so that it is more consistent
for testing
---
 test/test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test.cpp b/test/test.cpp
index 59c1e34..51f5f74 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -113,7 +113,7 @@ class TestSim : public Simulation {
 	}
 
 	bool checkFinished() const {
-		return (N_termination_events == 100000);
+		return (getN_objects_created() == 100000);
 	}
 
 	void executeCreationEvent(const std::list<Event*>::const_iterator event_it) {

From d4480b95d8685777feda82e6f91f632945cc05e4 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Wed, 9 May 2018 15:42:15 -0400
Subject: [PATCH 21/37] Simulation Class Testing Update

-increased diffusion test run to get more accurate statistics
---
 test/test.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/test.cpp b/test/test.cpp
index 51f5f74..3d9c2bb 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -113,7 +113,7 @@ class TestSim : public Simulation {
 	}
 
 	bool checkFinished() const {
-		return (getN_objects_created() == 100000);
+		return (getN_objects_created() == 200000);
 	}
 
 	void executeCreationEvent(const std::list<Event*>::const_iterator event_it) {
@@ -247,7 +247,7 @@ namespace SimulationTests {
 		while (!sim.checkFinished()) {
 			EXPECT_TRUE(sim.executeNextEvent());
 		}
-		EXPECT_EQ(100000, sim.getN_objects_created());
+		EXPECT_EQ(200000, sim.getN_objects_created());
 		double displacement = vector_avg(sim.displacement_data);
 		TestSim sim2;
 		params_base.Enable_FRM = true;
@@ -257,7 +257,7 @@ namespace SimulationTests {
 		while (!sim2.checkFinished()) {
 			EXPECT_TRUE(sim2.executeNextEvent());
 		}
-		EXPECT_EQ(100000, sim2.getN_objects_created());
+		EXPECT_EQ(200000, sim2.getN_objects_created());
 		double displacement2 = vector_avg(sim2.displacement_data);
 		EXPECT_NEAR(displacement, displacement2, 1e-2);
 		TestSim sim3;
@@ -268,7 +268,7 @@ namespace SimulationTests {
 		while (!sim3.checkFinished()) {
 			EXPECT_TRUE(sim3.executeNextEvent());
 		}
-		EXPECT_EQ(100000, sim3.getN_objects_created());
+		EXPECT_EQ(200000, sim3.getN_objects_created());
 		double displacement3 = vector_avg(sim3.displacement_data);
 		EXPECT_NEAR(displacement, displacement3, 1e-2);
 	}

From ca30f9b91e4793028593e62ccc57ad9f557836ab Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Wed, 9 May 2018 16:14:37 -0400
Subject: [PATCH 22/37] Simulation Class Testing Update

-increased tolerance on diffusion test results from different algorithms
---
 test/test.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/test.cpp b/test/test.cpp
index 3d9c2bb..c998df3 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -259,7 +259,7 @@ namespace SimulationTests {
 		}
 		EXPECT_EQ(200000, sim2.getN_objects_created());
 		double displacement2 = vector_avg(sim2.displacement_data);
-		EXPECT_NEAR(displacement, displacement2, 1e-2);
+		EXPECT_NEAR(displacement, displacement2, 5e-2);
 		TestSim sim3;
 		params_base.Enable_FRM = false;
 		params_base.Enable_selective_recalc = false;
@@ -270,7 +270,7 @@ namespace SimulationTests {
 		}
 		EXPECT_EQ(200000, sim3.getN_objects_created());
 		double displacement3 = vector_avg(sim3.displacement_data);
-		EXPECT_NEAR(displacement, displacement3, 1e-2);
+		EXPECT_NEAR(displacement, displacement3, 5e-2);
 	}
 
 }

From c3cd650d289dc3cde5bb5e9a17e3b04955d33a90 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Thu, 10 May 2018 18:41:28 -0400
Subject: [PATCH 23/37] Lattice Class Update

-added a chooseRandomNearestNeighbor function to random pick a nearest
neighbor of the current coordinates, which could be a generally valuable
function for building KMC simulations
---
 src/Lattice.cpp | 36 ++++++++++++++++++++++++++++++++++++
 src/Lattice.h   |  6 ++++++
 2 files changed, 42 insertions(+)

diff --git a/src/Lattice.cpp b/src/Lattice.cpp
index 7f660bf..e75c67f 100644
--- a/src/Lattice.cpp
+++ b/src/Lattice.cpp
@@ -144,6 +144,42 @@ bool Lattice::checkMoveValidity(const Coords& coords_initial, const int i, const
 	return true;
 }
 
+Coords Lattice::chooseRandomNearestNeighbor(const Coords& coords_i) {
+	int i = 0, j = 0, k = 0;
+	uniform_int_distribution<> dist(0, 5);
+	while (1) {
+		int rand_num = dist(*gen_ptr);
+		switch (rand_num) {
+		case 0:
+			i = -1;
+			break;
+		case 1:
+			i = 1;
+			break;
+		case 2:
+			j = -1;
+			break;
+		case 3:
+			j = 1;
+			break;
+		case 4:
+			k = -1;
+			break;
+		case 5:
+			k = 1;
+			break;
+		default:
+			break;
+		}
+		if (checkMoveValidity(coords_i, i, j, k)) {
+			break;
+		}
+	}
+	Coords coords_f;
+	calculateDestinationCoords(coords_i, i, j, k, coords_f);
+	return coords_f;
+}
+
 void Lattice::clearOccupancy(const Coords& coords) {
 	site_ptrs[getSiteIndex(coords)]->clearOccupancy();
 }
diff --git a/src/Lattice.h b/src/Lattice.h
index 1636f81..8ac8cac 100644
--- a/src/Lattice.h
+++ b/src/Lattice.h
@@ -126,6 +126,12 @@ class Lattice{
 		//! \return false if a move event is not possible.
 		bool checkMoveValidity(const Coords& coords_initial, const int i, const int j, const int k) const;
 
+		//! \brief Randomly selects a valid nearest neighbor site
+		//! \details Will choose a site across a periodic boundary if periodic boundaries are enabled.
+		//! \param coords_i is the Coords struct that designates the starting coordinates.
+		//! \return a Coords struct that represents the selected nearest neighbor site.
+		Coords chooseRandomNearestNeighbor(const Coords& coords_i);
+
 		//! \brief Clears the occupancy of the site located at the specified coordinates.
 		//! \param coords is the Coords struct that represents the coordinates of the site to be cleared.
 		void clearOccupancy(const Coords& coords);

From fe02ff2d0b7f60cdc4ae50605c3da086fe905cae Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Thu, 10 May 2018 18:42:51 -0400
Subject: [PATCH 24/37] Utils Update

-replaced malloc dynamic memory allocation with new to conform to
prefered C++ style and corrected deallocation statements
---
 src/Utils.cpp | 66 +++++++++++++++++++++++++--------------------------
 1 file changed, 33 insertions(+), 33 deletions(-)

diff --git a/src/Utils.cpp b/src/Utils.cpp
index 775cfba..b24c87e 100644
--- a/src/Utils.cpp
+++ b/src/Utils.cpp
@@ -165,11 +165,11 @@ namespace Utils {
 		MPI_Comm_size(MPI_COMM_WORLD, &nproc);
 		vector<double> output_vector;
 		if (procid == 0) {
-			data_sizes = (int *)malloc(sizeof(int)*nproc);
+			data_sizes = new int[nproc];
 		}
 		data_size = (int)input_vector.size();
-		data = (double *)malloc(sizeof(double)*data_size);
-		for (int i = 0; i < (int)input_vector.size(); i++) {
+		data = new double[data_size];
+		for (int i = 0; i < data_size; i++) {
 			data[i] = input_vector[i];
 		}
 		MPI_Gather(&data_size, 1, MPI_INT, data_sizes, 1, MPI_INT, 0, MPI_COMM_WORLD);
@@ -177,8 +177,8 @@ namespace Utils {
 			for (int i = 0; i < nproc; i++) {
 				data_count += data_sizes[i];
 			}
-			data_all = (double *)malloc(sizeof(double)*data_count);
-			data_displacement = (int *)malloc(sizeof(int)*nproc);
+			data_all = new double[data_count];
+			data_displacement = new int[nproc];
 			data_displacement[0] = 0;
 			for (int i = 1; i < nproc; i++) {
 				data_displacement[i] = data_displacement[i - 1] + data_sizes[i - 1];
@@ -202,10 +202,10 @@ namespace Utils {
 				output_vector.push_back(average);
 			}
 		}
-		delete data;
-		delete data_all;
-		delete data_sizes;
-		delete data_displacement;
+		delete[] data;
+		delete[] data_all;
+		delete[] data_sizes;
+		delete[] data_displacement;
 		return output_vector;
 	}
 
@@ -217,8 +217,8 @@ namespace Utils {
 		int procid;
 		MPI_Comm_rank(MPI_COMM_WORLD, &procid);
 		data_size = (int)input_vector.size();
-		data = (double *)malloc(sizeof(double)*data_size);
-		sum = (double *)malloc(sizeof(double)*data_size);
+		data = new double[data_size];
+		sum = new double[data_size];
 		for (int i = 0; i < (int)input_vector.size(); i++) {
 			data[i] = input_vector[i];
 		}
@@ -228,8 +228,8 @@ namespace Utils {
 				output_vector.push_back(sum[i]);
 			}
 		}
-		delete data;
-		delete sum;
+		delete[] data;
+		delete[] sum;
 		return output_vector;
 	}
 
@@ -241,8 +241,8 @@ namespace Utils {
 		int procid;
 		MPI_Comm_rank(MPI_COMM_WORLD, &procid);
 		data_size = (int)input_vector.size();
-		data = (int *)malloc(sizeof(int)*data_size);
-		sum = (int *)malloc(sizeof(int)*data_size);
+		data = new int[data_size];
+		sum = new int[data_size];
 		for (int i = 0; i < (int)input_vector.size(); i++) {
 			data[i] = input_vector[i];
 		}
@@ -252,8 +252,8 @@ namespace Utils {
 				output_vector.push_back(sum[i]);
 			}
 		}
-		delete data;
-		delete sum;
+		delete[] data;
+		delete[] sum;
 		return output_vector;
 	}
 
@@ -270,10 +270,10 @@ namespace Utils {
 		MPI_Comm_rank(MPI_COMM_WORLD, &procid);
 		MPI_Comm_size(MPI_COMM_WORLD, &nproc);
 		if (procid == 0) {
-			data_sizes = (int *)malloc(sizeof(int)*nproc);
+			data_sizes = new int[nproc];
 		}
 		data_size = (int)input_vector.size();
-		data = (double *)malloc(sizeof(double)*data_size);
+		data = new double[data_size];
 		for (int i = 0; i < (int)input_vector.size(); i++) {
 			data[i] = input_vector[i];
 		}
@@ -282,8 +282,8 @@ namespace Utils {
 			for (int i = 0; i < nproc; i++) {
 				data_count += data_sizes[i];
 			}
-			data_all = (double *)malloc(sizeof(double)*data_count);
-			data_displacement = (int *)malloc(sizeof(int)*nproc);
+			data_all = new double[data_count];
+			data_displacement = new int[nproc];
 			data_displacement[0] = 0;
 			for (int i = 1; i < nproc; i++) {
 				data_displacement[i] = data_displacement[i - 1] + data_sizes[i - 1];
@@ -295,10 +295,10 @@ namespace Utils {
 				output_vector.push_back(data_all[i]);
 			}
 		}
-		delete data;
-		delete data_all;
-		delete data_sizes;
-		delete data_displacement;
+		delete[] data;
+		delete[] data_all;
+		delete[] data_sizes;
+		delete[] data_displacement;
 		return output_vector;
 	}
 
@@ -315,10 +315,10 @@ namespace Utils {
 		MPI_Comm_rank(MPI_COMM_WORLD, &procid);
 		MPI_Comm_size(MPI_COMM_WORLD, &nproc);
 		if (procid == 0) {
-			data_sizes = (int *)malloc(sizeof(int)*nproc);
+			data_sizes = new int[nproc];
 		}
 		data_size = (int)input_vector.size();
-		data = (int *)malloc(sizeof(int)*data_size);
+		data = new int[data_size];
 		for (int i = 0; i < (int)input_vector.size(); i++) {
 			data[i] = input_vector[i];
 		}
@@ -327,8 +327,8 @@ namespace Utils {
 			for (int i = 0; i < nproc; i++) {
 				data_count += data_sizes[i];
 			}
-			data_all = (int *)malloc(sizeof(int)*data_count);
-			data_displacement = (int *)malloc(sizeof(int)*nproc);
+			data_all = new int[data_count];
+			data_displacement = new int[nproc];
 			data_displacement[0] = 0;
 			for (int i = 1; i < nproc; i++) {
 				data_displacement[i] = data_displacement[i - 1] + data_sizes[i - 1];
@@ -340,10 +340,10 @@ namespace Utils {
 				output_vector.push_back(data_all[i]);
 			}
 		}
-		delete data;
-		delete data_all;
-		delete data_sizes;
-		delete data_displacement;
+		delete[] data;
+		delete[] data_all;
+		delete[] data_sizes;
+		delete[] data_displacement;
 		return output_vector;
 	}
 

From f18d4c69a4606b5d495ce0c7815161da5ab44fc7 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Thu, 10 May 2018 22:46:10 -0400
Subject: [PATCH 25/37] Simulation Class Update

-refactored a number of functions to use C++11 container operation
functions with lambdas instead of traditional loops to make code more
concise a potentially faster as well
---
 src/Simulation.cpp | 57 ++++++++++++++++------------------------------
 1 file changed, 19 insertions(+), 38 deletions(-)

diff --git a/src/Simulation.cpp b/src/Simulation.cpp
index b14c329..3c8f6e5 100644
--- a/src/Simulation.cpp
+++ b/src/Simulation.cpp
@@ -102,18 +102,12 @@ vector<Object*> Simulation::findRecalcObjects(const Coords& coords_start, const
 }
 
 vector<Object*> Simulation::findRecalcNeighbors(const Coords& coords) const {
-	vector<Object*> neighbor_ptrs;
-	neighbor_ptrs.reserve(10);
-	Coords coords2;
 	const static int recalc_cutoff_sq_lat = (int)((Recalc_cutoff / lattice.getUnitSize())*(Recalc_cutoff / lattice.getUnitSize()));
-	int distance_sq_lat;
-	for (auto const &item : object_ptrs) {
-		coords2 = item->getCoords();
-		distance_sq_lat = lattice.calculateLatticeDistanceSquared(coords, coords2);
-		if (distance_sq_lat <= recalc_cutoff_sq_lat) {
-			neighbor_ptrs.push_back(item);
-		}
-	}
+	vector<Object*> neighbor_ptrs(object_ptrs.size());
+	auto it = copy_if(object_ptrs.begin(), object_ptrs.end(), neighbor_ptrs.begin(), [this,&coords](Object* element) {
+		return lattice.calculateLatticeDistanceSquared(coords, element->getCoords()) <= recalc_cutoff_sq_lat;
+	});
+	neighbor_ptrs.resize(std::distance(neighbor_ptrs.begin(), it));
 	return neighbor_ptrs;
 }
 
@@ -144,13 +138,9 @@ int Simulation::getId() const {
 }
 
 int Simulation::getN_events() const {
-	int count = 0;
-	for (auto const &item : event_ptrs) {
-		if (item!=nullptr && item->getExecutionTime() > 0) {
-			count++;
-		}
-	}
-	return count;
+	return count_if(event_ptrs.begin(), event_ptrs.end(), [](Event* element) {
+		return (element != nullptr && element->getExecutionTime() > 0);
+	});
 }
 
 long int Simulation::getN_events_executed() const {
@@ -199,15 +189,11 @@ double Simulation::rand01() {
 }
 
 void Simulation::removeEvent(Event* event_ptr) {
-	bool success = false;
-	for (auto it = event_ptrs.begin(); it != event_ptrs.end(); ++it) {
-		if (*it == event_ptr) {
-			event_ptrs.erase(it);
-			success = true;
-			break;
-		}
+	auto it = find_if(event_ptrs.begin(), event_ptrs.end(), [event_ptr](Event* element) {return element == event_ptr;});
+	if (it != event_ptrs.end()) {
+		event_ptrs.erase(it);
 	}
-	if (!success) {
+	else{
 		cout << "Error! The Event pointer could not be found in the event list and could not be removed." << endl;
 		Error_found = true;
 	}
@@ -219,21 +205,17 @@ void Simulation::removeObject(Object* object_ptr) {
 	// Delete the event pointer
 	removeEvent(*object_ptr->getEventIt());
 	// Delete the object pointer
-	bool success = false;
-	for (auto it = object_ptrs.begin(); it != object_ptrs.end(); ++it){
-		if (*it == object_ptr) {
-			object_ptrs.erase(it);
-			success = true;
-			break;
-		}
+	auto it = find_if(object_ptrs.begin(), object_ptrs.end(), [object_ptr](Object* element) {return element == object_ptr; });
+	if (it != object_ptrs.end()) {
+		object_ptrs.erase(it);
 	}
-    // Update counters
-    N_events_executed++;
-	// Error checking
-	if (!success) {
+	else {
 		cout << "Error! The Object pointer could not be found in the object list and could not be removed." << endl;
 		Error_found = true;
 	}
+    // Update counters
+    N_events_executed++;
+
 }
 
 void Simulation::setErrorMessage(const string& input_msg) {
@@ -251,4 +233,3 @@ void Simulation::setGeneratorSeed(int seed) {
 void Simulation::setTime(const double new_time){
     time_sim = new_time;
 }
-

From 1d74dd9dc8ba008b14986b3550c15c7016bf5b2a Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Fri, 11 May 2018 10:31:11 -0400
Subject: [PATCH 26/37] Lattice Class Correction

-corrected bug in chooseRandomNearestNeighbor function where i,j,k was
not being reset following the selection of an invalid site
---
 src/Lattice.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/Lattice.cpp b/src/Lattice.cpp
index e75c67f..8c9e30f 100644
--- a/src/Lattice.cpp
+++ b/src/Lattice.cpp
@@ -148,6 +148,9 @@ Coords Lattice::chooseRandomNearestNeighbor(const Coords& coords_i) {
 	int i = 0, j = 0, k = 0;
 	uniform_int_distribution<> dist(0, 5);
 	while (1) {
+		i = 0;
+		j = 0;
+		k = 0;
 		int rand_num = dist(*gen_ptr);
 		switch (rand_num) {
 		case 0:

From 092984d853bbedc326e4516255493f0a558b3b3b Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Fri, 11 May 2018 16:19:16 -0400
Subject: [PATCH 27/37] Utils Template Functions Update

-refactored template functions for calculating average and stdev of
vector data to use container operations for more concise code and
potential speed improvements
---
 src/Utils.h | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/src/Utils.h b/src/Utils.h
index 6001bae..e9b408a 100644
--- a/src/Utils.h
+++ b/src/Utils.h
@@ -265,7 +265,7 @@ namespace Utils {
 	}
 
 	//! \brief This template function efficienctly removes the duplicate entries from an input vector.
-	//! \details This algorithm allow efficient removal of duplicate vector objects when > or < comparison operators do not exist.
+	//! \details This algorithm allows efficient removal of duplicate vector objects when > or < comparison operators do not exist.
 	//! \param vec is the input vector to be operated on.
 	template<typename T>
 	void removeDuplicates(std::vector<T> &vec) {
@@ -289,11 +289,7 @@ namespace Utils {
 	//! \return The average of the data set in double format.
 	template<typename T, typename A>
 	double vector_avg(const std::vector<T, A>& data) {
-		double sum = 0;
-		for (auto const &item : data) {
-			sum += item;
-		}
-		return sum / data.size();
+		return accumulate(data.begin(), data.end(), 0.0) / (double)data.size();
 	}
 
 	//! \brief This template function calculates and returns the standard deviation in double format when given a vector of numerical datatypes.
@@ -301,12 +297,11 @@ namespace Utils {
 	//! \return The standard deviation of the data set in double format.
 	template<typename T, typename A>
 	double vector_stdev(const std::vector<T, A>& data) {
-		double sum = 0;
 		double avg = vector_avg(data);
-		for (auto const &item : data) {
-			sum += (item - avg)*(item - avg);
-		}
-		return sqrt(sum / (data.size() - 1));
+		double sum = accumulate(data.begin(), data.end(), 0.0, [avg](double& x, const T& element) {
+			return x + (element - avg)*(element - avg);
+		});
+		return sqrt(sum / (double)((int)data.size() - 1));
 	}
 }
 

From d9f1e0108d466d1a5498585009e2ba44941bdc0c Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Fri, 11 May 2018 16:21:22 -0400
Subject: [PATCH 28/37] Lattice Class Update

-renamed chooseRandomNearestNeighbor to chooseRandomUnoccupiedNeighbor
and updated the functionality so that it checks for lattice site
occupancy before returning the site coords
-refactored calculateDX, calculateDY, and calculateDZ functions to be
more concise
---
 src/Lattice.cpp | 70 ++++++++++++++++++++++++++-----------------------
 src/Lattice.h   |  7 ++---
 2 files changed, 41 insertions(+), 36 deletions(-)

diff --git a/src/Lattice.cpp b/src/Lattice.cpp
index 8c9e30f..e9a0f82 100644
--- a/src/Lattice.cpp
+++ b/src/Lattice.cpp
@@ -144,43 +144,50 @@ bool Lattice::checkMoveValidity(const Coords& coords_initial, const int i, const
 	return true;
 }
 
-Coords Lattice::chooseRandomNearestNeighbor(const Coords& coords_i) {
-	int i = 0, j = 0, k = 0;
-	uniform_int_distribution<> dist(0, 5);
-	while (1) {
-		i = 0;
-		j = 0;
-		k = 0;
-		int rand_num = dist(*gen_ptr);
-		switch (rand_num) {
-		case 0:
+Coords Lattice::chooseRandomUnoccupiedNeighbor(const Coords& coords_i) {
+	vector<Coords> coords_vec;
+	coords_vec.reserve(6);
+	Coords coords_f;
+	for (int n = 0; n < 6; n++) {
+		int i = 0;
+		int j = 0;
+		int k = 0;
+		if (n == 0) {
 			i = -1;
-			break;
-		case 1:
+		}
+		else if (n == 1) {
 			i = 1;
-			break;
-		case 2:
+		}
+		else if (n == 2) {
 			j = -1;
-			break;
-		case 3:
+		}
+		else if (n == 3) {
 			j = 1;
-			break;
-		case 4:
+		}
+		else if (n == 4) {
 			k = -1;
-			break;
-		case 5:
+		}
+		else if (n == 5) {
 			k = 1;
-			break;
-		default:
-			break;
 		}
 		if (checkMoveValidity(coords_i, i, j, k)) {
-			break;
+			calculateDestinationCoords(coords_i, i, j, k, coords_f);
+			if (!isOccupied(coords_f)) {
+				coords_vec.push_back(coords_f);
+			}
 		}
+	}	
+	if ((int)coords_vec.size() == 1) {
+		return coords_vec[0];
+	}
+	else if ((int)coords_vec.size()>1) {
+		uniform_int_distribution<> dist(0, (int)coords_vec.size()-1);
+		return coords_vec[dist(*gen_ptr)];
+	}
+	else {
+		coords_f = { -1,-1,-1 };
+		return coords_f;
 	}
-	Coords coords_f;
-	calculateDestinationCoords(coords_i, i, j, k, coords_f);
-	return coords_f;
 }
 
 void Lattice::clearOccupancy(const Coords& coords) {
@@ -197,20 +204,17 @@ Coords Lattice::generateRandomCoords() {
 
 int Lattice::generateRandomX() {
 	uniform_int_distribution<int> distx(0, Length - 1);
-	auto randx = bind(distx, ref(*gen_ptr));
-	return randx();
+	return distx(*gen_ptr);
 }
 
 int Lattice::generateRandomY() {
 	uniform_int_distribution<int> disty(0, Width - 1);
-	auto randy = bind(disty, ref(*gen_ptr));
-	return randy();
+	return disty(*gen_ptr);
 }
 
 int Lattice::generateRandomZ() {
 	uniform_int_distribution<int> distz(0, Height - 1);
-	auto randz = bind(distz, ref(*gen_ptr));
-	return randz();
+	return distz(*gen_ptr);
 }
 
 int Lattice::getHeight() const{
diff --git a/src/Lattice.h b/src/Lattice.h
index 8ac8cac..d410b2e 100644
--- a/src/Lattice.h
+++ b/src/Lattice.h
@@ -126,11 +126,12 @@ class Lattice{
 		//! \return false if a move event is not possible.
 		bool checkMoveValidity(const Coords& coords_initial, const int i, const int j, const int k) const;
 
-		//! \brief Randomly selects a valid nearest neighbor site
+		//! \brief Randomly selects a valid, unoccupied nearest neighbor site
 		//! \details Will choose a site across a periodic boundary if periodic boundaries are enabled.
 		//! \param coords_i is the Coords struct that designates the starting coordinates.
-		//! \return a Coords struct that represents the selected nearest neighbor site.
-		Coords chooseRandomNearestNeighbor(const Coords& coords_i);
+		//! \return a Coords struct that represents the selected unoccupied nearest neighbor site.
+		//! \return {-1,-1,-1} if there is no valid unoccupied neighbor
+		Coords chooseRandomUnoccupiedNeighbor(const Coords& coords_i);
 
 		//! \brief Clears the occupancy of the site located at the specified coordinates.
 		//! \param coords is the Coords struct that represents the coordinates of the site to be cleared.

From 481ccc180821e4416ddcae2f35f479f33cfe18d7 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Fri, 11 May 2018 16:22:03 -0400
Subject: [PATCH 29/37] Object Class Update

-updated calculateDisplacement function to remove unneeded double cast
---
 src/Object.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Object.cpp b/src/Object.cpp
index e9df691..0e78856 100644
--- a/src/Object.cpp
+++ b/src/Object.cpp
@@ -25,7 +25,7 @@ Object::Object(const double time,const int tag_num,const Coords& start_coords){
 }
 
 double Object::calculateDisplacement() const{
-    return sqrt((double)(coords_current.x+dx-coords_initial.x)*(coords_current.x+dx-coords_initial.x)+(coords_current.y+dy-coords_initial.y)*(coords_current.y+dy-coords_initial.y)+(coords_current.z+dz-coords_initial.z)*(coords_current.z+dz-coords_initial.z));
+    return sqrt((coords_current.x+dx-coords_initial.x)*(coords_current.x+dx-coords_initial.x)+(coords_current.y+dy-coords_initial.y)*(coords_current.y+dy-coords_initial.y)+(coords_current.z+dz-coords_initial.z)*(coords_current.z+dz-coords_initial.z));
 }
 
 Coords Object::getCoords() const{

From fd5b93d3b50061e18b01ddf910ab0e89783a16b9 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Mon, 14 May 2018 22:20:19 -0400
Subject: [PATCH 30/37] Random Number Generator Update

-updated to 64 bit mersenne twister
---
 src/Lattice.cpp  | 8 ++++----
 src/Lattice.h    | 4 ++--
 src/Simulation.h | 2 +-
 src/Utils.cpp    | 4 ++--
 src/Utils.h      | 4 ++--
 5 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/Lattice.cpp b/src/Lattice.cpp
index e9a0f82..4af43d7 100644
--- a/src/Lattice.cpp
+++ b/src/Lattice.cpp
@@ -12,7 +12,7 @@ Lattice::Lattice() {
 
 }
 
-void Lattice::init(const Parameters_Lattice& params, mt19937* generator_ptr) {
+void Lattice::init(const Parameters_Lattice& params, mt19937_64* generator_ptr) {
 	Enable_periodic_x = params.Enable_periodic_x;
 	Enable_periodic_y = params.Enable_periodic_y;
 	Enable_periodic_z = params.Enable_periodic_z;
@@ -176,12 +176,12 @@ Coords Lattice::chooseRandomUnoccupiedNeighbor(const Coords& coords_i) {
 				coords_vec.push_back(coords_f);
 			}
 		}
-	}	
+	}
 	if ((int)coords_vec.size() == 1) {
 		return coords_vec[0];
 	}
-	else if ((int)coords_vec.size()>1) {
-		uniform_int_distribution<> dist(0, (int)coords_vec.size()-1);
+	else if ((int)coords_vec.size() > 1) {
+		uniform_int_distribution<> dist(0, (int)coords_vec.size() - 1);
 		return coords_vec[dist(*gen_ptr)];
 	}
 	else {
diff --git a/src/Lattice.h b/src/Lattice.h
index d410b2e..bbb4a54 100644
--- a/src/Lattice.h
+++ b/src/Lattice.h
@@ -48,7 +48,7 @@ class Lattice{
 		//! \param params is a Parameters_Lattice struct that contains all of the required
 		//! parameters to initialize the Lattice object. 
 		//! \param generator_ptr is a pointer to a Mersenne twister number generator.
-        void init(const Parameters_Lattice& params, std::mt19937* generator_ptr);
+        void init(const Parameters_Lattice& params, std::mt19937_64* generator_ptr);
 
 		//! \brief Calculates the destination coordinates when given the starting coordinates and the displacement vector (i,j,k).
 		//! \details When the starting coordinates are near one or more of the lattice boundaries and periodic boundary conditions are enabled,
@@ -239,7 +239,7 @@ class Lattice{
 		int Height; // nm
 		double Unit_size; // nm
 		std::vector<Site*> site_ptrs;
-		std::mt19937* gen_ptr;
+		std::mt19937_64* gen_ptr;
 };
 
 #endif // LATTICE_H
diff --git a/src/Simulation.h b/src/Simulation.h
index 9942a7b..b94acaf 100644
--- a/src/Simulation.h
+++ b/src/Simulation.h
@@ -131,7 +131,7 @@ class Simulation{
 
     protected:
         //! Mersenne Twister random number generator
-		std::mt19937 generator;
+		std::mt19937_64 generator;
         //! Pointer to an output file stream that is used to print log messages to a logfile when logging is enabled.
 		std::ofstream* Logfile;
 		//! The Lattice object represents a three-dimensional lattice, its boundary conditions, and its occupancy.
diff --git a/src/Utils.cpp b/src/Utils.cpp
index b24c87e..5966e05 100644
--- a/src/Utils.cpp
+++ b/src/Utils.cpp
@@ -89,7 +89,7 @@ namespace Utils {
 		return hist;
 	}
 
-	void createExponentialDOSVector(std::vector<double>& data, const double mode, const double urbach_energy, std::mt19937& gen) {
+	void createExponentialDOSVector(std::vector<double>& data, const double mode, const double urbach_energy, std::mt19937_64& gen) {
 		exponential_distribution<double> dist_exp(1.0 / urbach_energy);
 		auto rand_exp = bind(dist_exp, ref(gen));
 		normal_distribution<double> dist_gaus(0, 2.0*urbach_energy / sqrt(2.0 * Pi));
@@ -106,7 +106,7 @@ namespace Utils {
 		}
 	}
 
-	void createGaussianDOSVector(std::vector<double>& data, const double mean, const double stdev, std::mt19937& gen) {
+	void createGaussianDOSVector(std::vector<double>& data, const double mean, const double stdev, std::mt19937_64& gen) {
 		normal_distribution<double> dist(mean, stdev);
 		auto rand_gaus = bind(dist, ref(gen));
 		for (auto &item : data) {
diff --git a/src/Utils.h b/src/Utils.h
index e9b408a..62d4b74 100644
--- a/src/Utils.h
+++ b/src/Utils.h
@@ -112,14 +112,14 @@ namespace Utils {
 	//! \param mode is the value of the peak of the distribution.
 	//! \param urbach_energy is the parameter that detemines the shape of the exponential tail side of the distribution.
 	//! \param gen is a Mersenne twister random number generator used to randomly draw numbers from the distribution.
-	void createExponentialDOSVector(std::vector<double>& data, const double mode, const double urbach_energy, std::mt19937& gen);
+	void createExponentialDOSVector(std::vector<double>& data, const double mode, const double urbach_energy, std::mt19937_64& gen);
 
 	//! \brief Creates a vector of doubles that has a Gaussian distribution.
 	//! \param data is the data vector where the numbers will be placed, which must be preallocated to the desired size.
 	//! \param mean is the position of the peak and center of the distribution.
 	//! \param stdev is the standard deviation of the distribution, which defines the width of the peak.
 	//! \param gen is a Mersenne twister random number generator used to randomly draw numbers from the distribution.
-	void createGaussianDOSVector(std::vector<double>& data, const double mean, const double stdev, std::mt19937& gen);
+	void createGaussianDOSVector(std::vector<double>& data, const double mean, const double stdev, std::mt19937_64& gen);
 
 	//! \brief Extracts a boolean value from a string containing "true" or "false".
 	//! \param input is the input string.

From e82723ed2983e81a4d4033e58beeb92fa0cd2b74 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Mon, 14 May 2018 22:22:03 -0400
Subject: [PATCH 31/37] Simulation Class Testing Update

-simplified TestSim class to test random walk simulations
-added tests to verify correct random walk simulations
---
 test/test.cpp | 489 +++++++++++++++++++++++++++++++++++---------------
 1 file changed, 344 insertions(+), 145 deletions(-)

diff --git a/test/test.cpp b/test/test.cpp
index c998df3..ff129ac 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -26,28 +26,26 @@ class TestSim : public Simulation {
 		MoveEvent(Simulation* simulation_ptr) : Event(simulation_ptr) {}
 		string getEventType() const { return "Move"; }
 	};
-	class TerminationEvent : public Event {
-	public:
-		TerminationEvent() : Event() {}
-		TerminationEvent(Simulation* simulation_ptr) : Event(simulation_ptr) {}
-		string getEventType() const { return "Termination"; }
-	};
 
 	// Data members
 	list<Object> objects;
 	list<Site> sites;
 	CreationEvent event_creation;
 	list<MoveEvent> events_move;
-	list<TerminationEvent> events_termination;
 	Event event_previous;
 	string event_previous_type;
+	Coords coords_creation;
+	int N_tests = 1;
+	int N_steps = 1;
+	double k_move = 1.0;
 	int N_move_events = 0;
 	int N_termination_events = 0;
+	vector<int> move_counts;
 	vector<double> displacement_data;
 
-	bool init(const Parameters_Simulation& params, const int id) {
+	bool init(const Parameters_Simulation& params) {
 		// Initialize Simulation base class
-		Simulation::init(params, id);
+		Simulation::init(params, 0);
 		// Initialize Sites
 		Site site;
 		sites.assign(lattice.getNumSites(), site);
@@ -57,132 +55,111 @@ class TestSim : public Simulation {
 		}
 		lattice.setSitePointers(site_ptrs);
 		// Perform test initialization
+		coords_creation = { lattice.getLength() / 2, lattice.getWidth() / 2, lattice.getHeight() / 2 };
 		CreationEvent event_creation_new(this);
 		event_creation = event_creation_new;
-		event_creation.setDestCoords(lattice.generateRandomCoords());
-		event_creation.calculateExecutionTime(1.0);
+		event_creation.calculateExecutionTime(0.01);
 		addEvent(&event_creation);
+		// Reserve memory
+		displacement_data.reserve(N_tests);
+		move_counts.reserve(N_tests);
 		return true;
 	}
 
 	void calculateNextEvent(Object* object_ptr) {
 		auto move_event_it = find_if(events_move.begin(), events_move.end(), [object_ptr](MoveEvent& a) { return a.getObjectPtr() == object_ptr; });
-		auto termination_event_it = find_if(events_termination.begin(), events_termination.end(), [object_ptr](TerminationEvent& a) { return a.getObjectPtr() == object_ptr; });
-		// Calculate move events
-		move_event_it->calculateExecutionTime(100);
+		move_event_it->calculateExecutionTime(k_move);
 		Coords coords_i = object_ptr->getCoords();
-		Coords coords_f;
-		int i = 0, j = 0, k = 0;
-		uniform_int_distribution<> dist(0, 5);
-		int rand_num = dist(generator);
-		switch (rand_num) {
-		case 0:
-			i = -1;
-			break;
-		case 1:
-			i = 1;
-			break;
-		case 2:
-			j = -1;
-			break;
-		case 3:
-			j = 1;
-			break;
-		case 4:
-			k = -1;
-			break;
-		case 5:
-			k = 1;
-			break;
-		default:
-			i = 1;
-			break;
-		}
-		lattice.calculateDestinationCoords(coords_i, i, j, k, coords_f);
-		move_event_it->setDestCoords(coords_f);
-		// Calculate termination event
-		termination_event_it->setDestCoords(coords_i);
-		termination_event_it->calculateExecutionTime(10);
-		// Select fastest event
-		if (move_event_it->getExecutionTime() < termination_event_it->getExecutionTime()) {
-			setObjectEvent(object_ptr, &(*move_event_it));
+		Coords coords_f = lattice.chooseRandomUnoccupiedNeighbor(coords_i);
+		if (coords_f.x == -1) {
+			setObjectEvent(object_ptr, nullptr);
 		}
 		else {
-			setObjectEvent(object_ptr, &(*termination_event_it));
+			move_event_it->setDestCoords(coords_f);
+			setObjectEvent(object_ptr, &(*move_event_it));
 		}
 	}
 
 	bool checkFinished() const {
-		return (getN_objects_created() == 200000);
+		return (getN_objects_created() == N_tests);
 	}
 
-	void executeCreationEvent(const std::list<Event*>::const_iterator event_it) {
-		Event* event_ptr = *event_it;
-		Coords coords_dest = event_ptr->getDestCoords();
-		Object object(event_ptr->getExecutionTime(),getN_objects_created()+1,coords_dest);
-		objects.push_back(object);
-		addObject(&objects.back());
-		Simulation* sim_ptr = this;
-		MoveEvent event1(sim_ptr);
-		event1.setObjectPtr(&objects.back());
-		events_move.push_back(event1);
-		TerminationEvent event2(sim_ptr);
-		event2.setObjectPtr(&objects.back());
-		events_termination.push_back(event2);
+	Coords executeCreationEvent() {
+		Coords coords_dest = coords_creation;
+		if(lattice.isOccupied(coords_dest)) {
+			coords_dest = lattice.chooseRandomUnoccupiedNeighbor(coords_dest);
+		}
+		if (coords_dest.x != -1) {
+			Object object(getTime(), getN_objects_created(), coords_dest);
+			objects.push_back(object);
+			addObject(&objects.back());
+			Simulation* sim_ptr = this;
+			MoveEvent event1(sim_ptr);
+			event1.setObjectPtr(&objects.back());
+			events_move.push_back(event1);
+			move_counts.push_back(0);
+		}
 		// Calculate next creation event
-		event_creation.setDestCoords(lattice.generateRandomCoords());
-		event_creation.calculateExecutionTime(1.0);
+		event_creation.calculateExecutionTime(0.01);
+		return coords_dest;
 	}
 
 	void executeMoveEvent(const std::list<Event*>::const_iterator event_it) {
 		Event* event_ptr = *event_it;
 		moveObject(event_ptr->getObjectPtr(), event_ptr->getDestCoords());
+		move_counts[event_ptr->getObjectPtr()->getTag()]++;
 		N_move_events++;
 	}
 
 	bool executeNextEvent() {
+		// Check if any objects are finished
+		for (auto& item : objects) {
+			if (move_counts[item.getTag()]==N_steps) {
+				displacement_data.push_back(item.calculateDisplacement());
+				executeTerminationEvent(&item);
+				break;
+			}
+		}
 		auto event_it = chooseNextEvent();
 		Event* event_ptr = *event_it;
 		string event_type = event_ptr->getEventType();
 		event_previous = *event_ptr;
-		event_previous_type = event_type;
+		event_previous_type = event_ptr->getEventType();
 		Coords coords_i;
 		Coords coords_f = event_ptr->getDestCoords();
 		setTime(event_ptr->getExecutionTime());
-		if (event_type.compare("Creation")==0) {
-			executeCreationEvent(event_it);
+		if (event_type.compare("Creation") == 0) {
+			coords_f = executeCreationEvent();
 			coords_i = coords_f;
 		}
 		else {
 			coords_i = event_ptr->getObjectPtr()->getCoords();
-			if (event_type.compare("Move")==0) {
+			coords_f = event_ptr->getDestCoords();
+			if (event_type.compare("Move") == 0) {
 				executeMoveEvent(event_it);
 			}
-			else if (event_type.compare("Termination")==0) {
-				Object* object_ptr = (*event_it)->getObjectPtr();
-				displacement_data.push_back(object_ptr->calculateDisplacement());
-				executeTerminationEvent(event_it);
-			}
 			else {
 				return false;
 			}
 		}
-		auto object_vec = findRecalcObjects(coords_i, coords_f);
-		for (auto item : object_vec) {
-			calculateNextEvent(item);
+		if (coords_f.x != -1) {
+			auto object_vec = findRecalcObjects(coords_i, coords_f);
+			for (auto item : object_vec) {
+				calculateNextEvent(item);
+			}
 		}
 		return true;
 	}
 
-	void executeTerminationEvent(const std::list<Event*>::const_iterator event_it) {
-		Object* object_ptr = (*event_it)->getObjectPtr();
+	void executeTerminationEvent(Object* object_ptr) {
 		// Remove object from Simulation class
 		removeObject(object_ptr);
-		// Remove local events
+		// Remove local move event
 		auto move_event_it = find_if(events_move.begin(), events_move.end(), [object_ptr](MoveEvent& a) { return a.getObjectPtr() == object_ptr; });
 		events_move.erase(move_event_it);
-		auto termination_event_it = find_if(events_termination.begin(), events_termination.end(), [object_ptr](TerminationEvent& a) { return a.getObjectPtr() == object_ptr; });
-		events_termination.erase(termination_event_it);
+		// Remove local object
+		auto object_it = find_if(objects.begin(), objects.end(), [object_ptr](Object& a) { return a.getTag() == object_ptr->getTag(); });
+		objects.erase(object_it);
 		N_termination_events++;
 	}
 
@@ -193,7 +170,10 @@ class TestSim : public Simulation {
 	vector<Event*> getAllEventPtrs() const {
 		return getAllEventPtrs();
 	}
-	
+
+	Coords getRandomCoords() {
+		return lattice.generateRandomCoords();
+	}
 };
 
 namespace SimulationTests {
@@ -208,9 +188,9 @@ namespace SimulationTests {
 				params_base.Enable_periodic_x = true;
 				params_base.Enable_periodic_y = true;
 				params_base.Enable_periodic_z = true;
-				params_base.Length = 50;
-				params_base.Width = 50;
-				params_base.Height = 50;
+				params_base.Length = 200;
+				params_base.Width = 200;
+				params_base.Height = 200;
 				params_base.Unit_size = 1.0;
 				params_base.Temperature = 300;
 				params_base.Enable_FRM = false;
@@ -219,8 +199,10 @@ namespace SimulationTests {
 				params_base.Enable_full_recalc = false;
 			}
 			// Initialize TestSim object
-			sim.init(params_base, 0);
-			sim.setGeneratorSeed(0);
+			sim.init(params_base);
+			sim.N_tests = 10000;
+			sim.N_steps = 500;
+			sim.k_move = 1000;
 		}
 	};
 
@@ -229,7 +211,7 @@ namespace SimulationTests {
 		EXPECT_FALSE(sim.isLoggingEnabled());
 		EXPECT_DOUBLE_EQ(0.0, sim.getTime());
 		EXPECT_EQ(300, sim.getTemp());
-		EXPECT_DOUBLE_EQ(125000e-21, sim.getVolume());
+		EXPECT_DOUBLE_EQ(params_base.Length*params_base.Width*params_base.Height*1e-21, sim.getVolume());
 	}
 
 	TEST_F(SimulationTest, EventExecutionTests) {
@@ -237,42 +219,169 @@ namespace SimulationTests {
 		EXPECT_EQ(1, sim.getN_events());
 		EXPECT_TRUE(sim.executeNextEvent());
 		EXPECT_EQ(1, (int)sim.objects.size());
-		EXPECT_EQ(1, sim.objects.front().getTag());
+		EXPECT_EQ(0, sim.objects.front().getTag());
 		EXPECT_EQ(2, sim.getN_events());
 		EXPECT_EQ(1, sim.getN_events_executed());
 		EXPECT_FALSE(sim.checkFinished());
+		// Check event destination coords
+		vector<Coords> data(20000);
+		for (int i = 0; i < 10; i++) {
+			for (auto& item : data) {
+				sim.calculateNextEvent(&sim.objects.front());
+				item = sim.events_move.front().getDestCoords();
+			}
+			auto site_options(data);
+			removeDuplicates(site_options);
+			EXPECT_EQ(6, (int)site_options.size());
+			for (auto item : site_options) {
+				int count = count_if(data.begin(), data.end(), [item](Coords element) {return element == item; });
+				EXPECT_NEAR(1.0 / 6.0, (double)count / (double)data.size(), 2e-2);
+			}
+			EXPECT_TRUE(sim.executeNextEvent());
+		}
 	}
 
-	TEST_F(SimulationTest, KMCAlgorithmTests) {
+	TEST_F(SimulationTest, DisplacementTests) {
+		params_base.Enable_periodic_x = false;
+		params_base.Enable_periodic_y = false;
+		params_base.Enable_periodic_z = false;
+		params_base.Length = 100;
+		params_base.Width = 100;
+		params_base.Height = 100;
+		TestSim sim2;
+		sim2.init(params_base);
+		sim2.coords_creation = sim2.getRandomCoords();
+		sim2.N_tests = 1000;
+		sim2.N_steps = 500;
+		sim2.k_move = 1000;
+		double displacement;
+		vector<Coords> creation_coords;
+		EXPECT_TRUE(sim2.executeNextEvent());
+		while (!sim2.checkFinished()) {
+			if (sim2.event_previous_type.compare("Creation") == 0) {
+				creation_coords.push_back(sim2.objects.back().getCoords());
+				EXPECT_TRUE(sim2.coords_creation==creation_coords.back());
+				sim2.coords_creation = sim2.getRandomCoords();
+			}
+			Coords coords_i = creation_coords[sim2.objects.front().getTag()];
+			Coords coords = sim2.objects.front().getCoords();
+			displacement = sim2.objects.front().calculateDisplacement();
+			EXPECT_DOUBLE_EQ(sqrt((coords.x-coords_i.x)*(coords.x-coords_i.x) + (coords.y-coords_i.y)*(coords.y-coords_i.y) + (coords.z-coords_i.z)*(coords.z-coords_i.z)), displacement);
+			EXPECT_TRUE(sim2.executeNextEvent());
+		}
+	}
+
+	TEST_F(SimulationTest, 3DRandomWalkTests) {
+		// 3D
 		while (!sim.checkFinished()) {
 			EXPECT_TRUE(sim.executeNextEvent());
+			if (sim.event_previous.getEventType().compare("Move") == 0) {
+				EXPECT_EQ(sim.event_previous.getDestCoords(), sim.event_previous.getObjectPtr()->getCoords());
+			}
 		}
-		EXPECT_EQ(200000, sim.getN_objects_created());
+		EXPECT_EQ(10000, sim.getN_objects_created());
 		double displacement = vector_avg(sim.displacement_data);
-		TestSim sim2;
+		double dim = 3.0;
+		double expected_val = sqrt(2.0 * sim.N_steps / dim)*(tgamma((dim + 1.0) / 2.0) / tgamma(dim / 2.0));
+		EXPECT_NEAR(expected_val, displacement, 2e-2*expected_val);
+	}
+
+	TEST_F(SimulationTest, 2DRandomWalkTests) {
+		// 2D
+		params_base.Enable_periodic_x = true;
+		params_base.Enable_periodic_y = true;
+		params_base.Enable_periodic_z = false;
+		params_base.Length = 200;
+		params_base.Width = 200;
+		params_base.Height = 1;
+		TestSim sim2D;
+		sim2D.init(params_base);
+		sim2D.N_tests = 10000;
+		sim2D.N_steps = 500;
+		sim2D.k_move = 1000;
+		while (!sim2D.checkFinished()) {
+			EXPECT_TRUE(sim2D.executeNextEvent());
+		}
+		double displacement2D = vector_avg(sim2D.displacement_data);
+		double dim = 2.0;
+		double expected_val = sqrt(2.0 * sim2D.N_steps / dim)*(tgamma((dim + 1.0) / 2.0) / tgamma(dim / 2.0));
+		EXPECT_NEAR(expected_val, displacement2D, 2e-2*expected_val);
+	}
+
+	TEST_F(SimulationTest, 1DRandomWalkTests) {
+		// 1D
+		params_base.Enable_periodic_x = true;
+		params_base.Enable_periodic_y = false;
+		params_base.Enable_periodic_z = false;
+		params_base.Length = 200;
+		params_base.Width = 1;
+		params_base.Height = 1;
+		TestSim sim1D;
+		sim1D.init(params_base);
+		sim1D.N_tests = 10000;
+		sim1D.N_steps = 500;
+		sim1D.k_move = 1000;
+		while (!sim1D.checkFinished()) {
+			EXPECT_TRUE(sim1D.executeNextEvent());
+		}
+		double displacement1D = vector_avg(sim1D.displacement_data);
+		double dim = 1.0;
+		double expected_val = sqrt(2.0 * sim1D.N_steps / dim)*(tgamma((dim + 1.0) / 2.0) / tgamma(dim / 2.0));
+		EXPECT_NEAR(expected_val, displacement1D, 2e-2*expected_val);
+	}
+
+	TEST_F(SimulationTest, AlgorithmTests) {
+		// Selective recalculation method
+		sim = TestSim();
+		params_base.Enable_FRM = false;
+		params_base.Enable_selective_recalc = true;
+		params_base.Recalc_cutoff = 3;
+		params_base.Enable_full_recalc = false;
+		params_base.Enable_periodic_x = true;
+		params_base.Enable_periodic_y = true;
+		params_base.Enable_periodic_z = true;
+		params_base.Length = 200;
+		params_base.Width = 200;
+		params_base.Height = 200;
+		sim.init(params_base);
+		sim.N_tests = 1000;
+		sim.N_steps = 1000;
+		sim.k_move = 1000;
+		while (!sim.checkFinished()) {
+			EXPECT_TRUE(sim.executeNextEvent());
+		}
+		double displacement1 = vector_avg(sim.displacement_data);
+		// First reaction method
+		sim = TestSim();
 		params_base.Enable_FRM = true;
 		params_base.Enable_selective_recalc = false;
 		params_base.Enable_full_recalc = false;
-		sim2.init(params_base, 0);
-		while (!sim2.checkFinished()) {
-			EXPECT_TRUE(sim2.executeNextEvent());
+		sim.init(params_base);
+		sim.N_tests = 1000;
+		sim.N_steps = 1000;
+		sim.k_move = 1000;
+		while (!sim.checkFinished()) {
+			EXPECT_TRUE(sim.executeNextEvent());
 		}
-		EXPECT_EQ(200000, sim2.getN_objects_created());
-		double displacement2 = vector_avg(sim2.displacement_data);
-		EXPECT_NEAR(displacement, displacement2, 5e-2);
-		TestSim sim3;
+		double displacement2 = vector_avg(sim.displacement_data);
+		// Full recalculation method
+		sim = TestSim();
 		params_base.Enable_FRM = false;
 		params_base.Enable_selective_recalc = false;
 		params_base.Enable_full_recalc = true;
-		sim3.init(params_base, 0);
-		while (!sim3.checkFinished()) {
-			EXPECT_TRUE(sim3.executeNextEvent());
+		sim.init(params_base);
+		sim.N_tests = 1000;
+		sim.N_steps = 1000;
+		sim.k_move = 1000;
+		while (!sim.checkFinished()) {
+			EXPECT_TRUE(sim.executeNextEvent());
 		}
-		EXPECT_EQ(200000, sim3.getN_objects_created());
-		double displacement3 = vector_avg(sim3.displacement_data);
-		EXPECT_NEAR(displacement, displacement3, 5e-2);
+		double displacement3 = vector_avg(sim.displacement_data);
+		// Check different displacement values
+		EXPECT_NEAR(displacement1, displacement2, 5e-2*displacement1);
+		EXPECT_NEAR(displacement1, displacement3, 5e-2*displacement1);
+		EXPECT_NEAR(displacement2, displacement3, 5e-2*displacement2);
 	}
-
 }
 
 namespace UtilsTests {
@@ -522,35 +631,35 @@ namespace UtilsTests {
 	}
 }
 
-namespace LatticeTests{
-		
+namespace LatticeTests {
+
 	class LatticeTest : public ::testing::Test {
-		protected:
-			mt19937 gen;
-			Parameters_Lattice params_lattice;
-			vector<Site> sites;
-			Lattice lattice;
-
-			void SetUp() {
-				gen.seed(std::random_device{}());
-				// Setup params
-				params_lattice.Enable_periodic_x = true;
-				params_lattice.Enable_periodic_y = true;
-				params_lattice.Enable_periodic_z = true;
-				params_lattice.Length = 50;
-				params_lattice.Width = 50;
-				params_lattice.Height = 50;
-				params_lattice.Unit_size = 1.0;
-				// Initialize Lattice object
-				lattice.init(params_lattice, &gen);
-				Site site;
-				sites.assign(lattice.getNumSites(), site);
-				vector<Site*> site_ptrs((int)sites.size());
-				for (int i = 0; i < (int)sites.size(); i++) {
-					site_ptrs[i] = &sites[i];
-				}
-				lattice.setSitePointers(site_ptrs);
+	protected:
+		mt19937_64 gen;
+		Parameters_Lattice params_lattice;
+		vector<Site> sites;
+		Lattice lattice;
+
+		void SetUp() {
+			gen.seed(std::random_device{}());
+			// Setup params
+			params_lattice.Enable_periodic_x = true;
+			params_lattice.Enable_periodic_y = true;
+			params_lattice.Enable_periodic_z = true;
+			params_lattice.Length = 50;
+			params_lattice.Width = 50;
+			params_lattice.Height = 50;
+			params_lattice.Unit_size = 1.0;
+			// Initialize Lattice object
+			lattice.init(params_lattice, &gen);
+			Site site;
+			sites.assign(lattice.getNumSites(), site);
+			vector<Site*> site_ptrs((int)sites.size());
+			for (int i = 0; i < (int)sites.size(); i++) {
+				site_ptrs[i] = &sites[i];
 			}
+			lattice.setSitePointers(site_ptrs);
+		}
 	};
 
 	TEST_F(LatticeTest, InitializationTests) {
@@ -559,7 +668,7 @@ namespace LatticeTests{
 		EXPECT_EQ(50, lattice.getHeight());
 		EXPECT_DOUBLE_EQ(1.0, lattice.getUnitSize());
 		EXPECT_EQ((long int)50 * 50 * 50, lattice.getNumSites());
-		EXPECT_DOUBLE_EQ(125000e-21,lattice.getVolume());
+		EXPECT_DOUBLE_EQ(125000e-21, lattice.getVolume());
 	}
 
 	TEST_F(LatticeTest, CalculateDestCoordsTests) {
@@ -597,8 +706,8 @@ namespace LatticeTests{
 		EXPECT_EQ(lattice.calculateDX(coords_i, coords_f), 0);
 		EXPECT_EQ(lattice.calculateDY(coords_i, coords_f), 50);
 		EXPECT_EQ(lattice.calculateDZ(coords_i, coords_f), -50);
-		coords_i = {1, 49, 0};
-		coords_f = {0, 0, 49};
+		coords_i = { 1, 49, 0 };
+		coords_f = { 0, 0, 49 };
 		EXPECT_EQ(lattice.calculateDX(coords_i, coords_f), 0);
 		EXPECT_EQ(lattice.calculateDY(coords_i, coords_f), -50);
 		EXPECT_EQ(lattice.calculateDZ(coords_i, coords_f), 50);
@@ -653,6 +762,95 @@ namespace LatticeTests{
 		EXPECT_NEAR(lattice.getHeight() / sqrt(12.0), vector_stdev(zcoords), 1e-2);
 	}
 
+	TEST_F(LatticeTest, RandomUnoccupiedNeighborTests) {
+		vector<int> data(30000);
+		for (int i = 0; i < 8; i++) {
+			Coords coords = lattice.generateRandomCoords();
+			for (auto& item : data) {
+				Coords coords_new = lattice.chooseRandomUnoccupiedNeighbor(coords);
+				EXPECT_FALSE(coords_new == coords);
+				item = lattice.getSiteIndex(coords_new);
+			}
+			auto site_options(data);
+			removeDuplicates(site_options);
+			EXPECT_EQ(6, (int)site_options.size());
+			for (auto item : site_options) {
+				int count = count_if(data.begin(), data.end(), [item](int element) {return element == item; });
+				EXPECT_NEAR(1.0 / 6.0, (double)count/(double)data.size(), 1e-2);
+			}
+		}
+	}
+
+	TEST_F(LatticeTest, 2DTests) {
+		// Initialize 2D Lattice object
+		params_lattice.Enable_periodic_x = true;
+		params_lattice.Enable_periodic_y = true;
+		params_lattice.Enable_periodic_z = false;
+		params_lattice.Length = 50;
+		params_lattice.Width = 50;
+		params_lattice.Height = 1;
+		params_lattice.Unit_size = 1.0;
+		Lattice lattice2D;
+		lattice2D.init(params_lattice, &gen);
+		Site site;
+		sites.assign(lattice2D.getNumSites(), site);
+		vector<Site*> site_ptrs((int)sites.size());
+		for (int i = 0; i < (int)sites.size(); i++) {
+			site_ptrs[i] = &sites[i];
+		}
+		lattice2D.setSitePointers(site_ptrs);
+		// Check random neighbor site generation in 2D
+		vector<int> data(30000);
+		for (int i = 0; i < 8; i++) {
+			Coords coords = lattice2D.generateRandomCoords();
+			for (auto& item : data) {
+				item = lattice2D.getSiteIndex(lattice2D.chooseRandomUnoccupiedNeighbor(coords));
+			}
+			auto site_options(data);
+			removeDuplicates(site_options);
+			EXPECT_EQ(4, (int)site_options.size());
+			for (auto item : site_options) {
+				int count = count_if(data.begin(), data.end(), [item](int element) {return element == item; });
+				EXPECT_NEAR(1.0 / 4.0, (double)count/(double)data.size(), 1e-2);
+			}
+		}
+	}
+
+	TEST_F(LatticeTest, 1DTests) {
+		// Initialize 1D Lattice object
+		params_lattice.Enable_periodic_x = true;
+		params_lattice.Enable_periodic_y = false;
+		params_lattice.Enable_periodic_z = false;
+		params_lattice.Length = 50;
+		params_lattice.Width = 1;
+		params_lattice.Height = 1;
+		params_lattice.Unit_size = 1.0;
+		Lattice lattice1D;
+		lattice1D.init(params_lattice, &gen);
+		Site site;
+		sites.assign(lattice1D.getNumSites(), site);
+		vector<Site*> site_ptrs((int)sites.size());
+		for (int i = 0; i < (int)sites.size(); i++) {
+			site_ptrs[i] = &sites[i];
+		}
+		lattice1D.setSitePointers(site_ptrs);
+		// Check random neighbor site generation in 1D
+		vector<int> data(30000);
+		for (int i = 0; i < 8; i++) {
+			Coords coords = lattice1D.generateRandomCoords();
+			for (auto& item : data) {
+				item = lattice1D.getSiteIndex(lattice1D.chooseRandomUnoccupiedNeighbor(coords));
+			}
+			auto site_options(data);
+			removeDuplicates(site_options);
+			EXPECT_EQ(2, (int)site_options.size());
+			for (auto item : site_options) {
+				int count = count_if(data.begin(), data.end(), [item](int element) {return element == item; });
+				EXPECT_NEAR(1.0 / 2.0, (double)count / (double)data.size(), 1e-2);
+			}
+		}
+	}
+
 	TEST_F(LatticeTest, LatticeDistanceTests) {
 		Coords coords_i{ 49, 49, 49 };
 		Coords coords_f{ 1, 49, 47 };
@@ -708,23 +906,24 @@ namespace LatticeTests{
 
 	TEST_F(LatticeTest, SiteTests) {
 		Site site;
+		EXPECT_FALSE(site.isOccupied());
 		vector<Site*> site_ptrs(10, &site);
 		EXPECT_FALSE(lattice.setSitePointers(site_ptrs));
 		site_ptrs.assign(50 * 50 * 50, &site);
 		EXPECT_TRUE(lattice.setSitePointers(site_ptrs));
-		Coords coords{5,6,7};
+		Coords coords{ 5,6,7 };
 		Site* site1 = *lattice.getSiteIt(coords);
 		Site* site2 = site_ptrs[lattice.getSiteIndex(coords)];
-		EXPECT_EQ(site1,site2);
+		EXPECT_EQ(site1, site2);
 		// Check for sites and indices outside the lattice
-		coords = {0, 60, 0};
-		EXPECT_THROW(lattice.getSiteIndex(coords),out_of_range);
-		EXPECT_THROW(lattice.getSiteCoords(150000),out_of_range);
+		coords = { 0, 60, 0 };
+		EXPECT_THROW(lattice.getSiteIndex(coords), out_of_range);
+		EXPECT_THROW(lattice.getSiteCoords(150000), out_of_range);
 		// Check site object assignment and clearing
 		Object object;
 		site.setObjectPtr(&object);
 		EXPECT_TRUE(site.isOccupied());
-		EXPECT_EQ(&object,site.getObjectPtr());
+		EXPECT_EQ(&object, site.getObjectPtr());
 		site.clearOccupancy();
 		EXPECT_FALSE(site.isOccupied());
 	}
@@ -753,7 +952,7 @@ namespace EventTests {
 			params_base.Enable_full_recalc = false;
 			}
 			// Initialize TestSim object
-			test_sim.init(params_base, 0);
+			test_sim.init(params_base);
 		}
 	};
 	

From a382b841fcd3e59d1b4764552a8af57f92a2a0b9 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Mon, 14 May 2018 22:32:17 -0400
Subject: [PATCH 32/37] Testing Update

-updated tests to use 64 bit mersenne twister random number generators
---
 test/test.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/test.cpp b/test/test.cpp
index ff129ac..1e87a06 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -398,7 +398,7 @@ namespace UtilsTests {
 	}
 
 	TEST(UtilsTests, CalculateProbabilityHistTests) {
-		mt19937 gen(std::random_device{}());
+		mt19937_64 gen(std::random_device{}());
 		uniform_real_distribution<> dist(0, 100);
 		vector<double> data((int)1e7);
 		for (int i = 0; i < (int)data.size(); i++) {
@@ -433,7 +433,7 @@ namespace UtilsTests {
 	}
 
 	TEST(UtilsTests, ExponentialDOSTests) {
-		mt19937 gen(std::random_device{}());
+		mt19937_64 gen(std::random_device{}());
 		vector<double> data((int)2e7, 0.0);
 		createExponentialDOSVector(data, 0.0, 0.1, gen);
 		auto hist = calculateProbabilityHist(data, 1000);
@@ -452,7 +452,7 @@ namespace UtilsTests {
 	}
 
 	TEST(UtilsTests, GaussianDOSTests) {
-		mt19937 gen(std::random_device{}());
+		mt19937_64 gen(std::random_device{}());
 		vector<double> data((int)3e7, 0.0);
 		createGaussianDOSVector(data, 0.0, 0.15, gen);
 		EXPECT_NEAR(0.0, vector_avg(data), 1e-4);

From acd4b8508be4ea1fd5d3530d3ea837f6dacad02b Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Tue, 15 May 2018 15:06:55 -0400
Subject: [PATCH 33/37] Simulation Class Testing

-added several new tests to increase test coverage
---
 test/test.cpp | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/test/test.cpp b/test/test.cpp
index 1e87a06..6cbceac 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -79,6 +79,12 @@ class TestSim : public Simulation {
 			setObjectEvent(object_ptr, &(*move_event_it));
 		}
 	}
+	
+	bool checkErrorMessageFunctions(string msg_in){
+		setErrorMessage(msg_in);
+		string msg_out = getErrorMessage();
+		return msg_in.compare(msg_out)==0;
+	}
 
 	bool checkFinished() const {
 		return (getN_objects_created() == N_tests);
@@ -203,6 +209,7 @@ namespace SimulationTests {
 			sim.N_tests = 10000;
 			sim.N_steps = 500;
 			sim.k_move = 1000;
+			sim.setGeneratorSeed(std::random_device{}());
 		}
 	};
 
@@ -223,6 +230,24 @@ namespace SimulationTests {
 		EXPECT_EQ(2, sim.getN_events());
 		EXPECT_EQ(1, sim.getN_events_executed());
 		EXPECT_FALSE(sim.checkFinished());
+		// Check objects and events
+		auto object_ptrs = sim.getAllObjectPtrs();
+		for(int i=0; i<(int)sim.objects.size(); i++){
+			auto it = sim.objects.begin();
+			advance(it,i);
+			EXPECT_TRUE(&(*it)==object_ptrs[i]);
+		}
+		auto event_ptrs = sim.getAllEventPtrs();
+		for(int i=0; i<(int)event_ptrs.size(); i++){
+			if(i==0){
+				EXPECT_TRUE(&sim.event_creation==event_ptrs[i]);
+			}
+			else{
+				auto it = sim.events_move.begin();
+				advance(it,i);
+				EXPECT_TRUE(&(*it)==event_ptrs[i+1]);
+			}
+		}
 		// Check event destination coords
 		vector<Coords> data(20000);
 		for (int i = 0; i < 10; i++) {
@@ -382,6 +407,13 @@ namespace SimulationTests {
 		EXPECT_NEAR(displacement1, displacement3, 5e-2*displacement1);
 		EXPECT_NEAR(displacement2, displacement3, 5e-2*displacement2);
 	}
+	
+	TEST_F(SimulationTest, ErrorMessageTests) {
+		EXPECT_TRUE(sim.checkErrorMessageFunctions("Error!"));
+		EXPECT_TRUE(sim.checkErrorMessageFunctions("Error! There is a problem."));
+		EXPECT_TRUE(sim.checkErrorMessageFunctions(" "));
+		EXPECT_TRUE(sim.checkErrorMessageFunctions(""));
+	}
 }
 
 namespace UtilsTests {

From cab5a806f7b42282877477c771f550a337e522af Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Tue, 15 May 2018 15:30:47 -0400
Subject: [PATCH 34/37] Simulation Class Testing Update

-corrected bug with one of the tests
---
 test/test.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/test.cpp b/test/test.cpp
index 6cbceac..be6cae2 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -170,11 +170,11 @@ class TestSim : public Simulation {
 	}
 
 	vector<Object*> getAllObjectPtrs() const {
-		return getAllObjectPtrs();
+		return Simulation::getAllObjectPtrs();
 	}
 
 	vector<Event*> getAllEventPtrs() const {
-		return getAllEventPtrs();
+		return Simulation::getAllEventPtrs();
 	}
 
 	Coords getRandomCoords() {
@@ -244,8 +244,8 @@ namespace SimulationTests {
 			}
 			else{
 				auto it = sim.events_move.begin();
-				advance(it,i);
-				EXPECT_TRUE(&(*it)==event_ptrs[i+1]);
+				advance(it,i-1);
+				EXPECT_TRUE(&(*it)==event_ptrs[i]);
 			}
 		}
 		// Check event destination coords

From 0c8271da1940723a1a6080f793d3fa9f85c0f81a Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Tue, 15 May 2018 16:18:30 -0400
Subject: [PATCH 35/37] Documentation Update

-updated Doxygen documentation based on latest source code changes
---
 docs/_lattice_8h_source.html       | 45 +++++++-------
 docs/_simulation_8h_source.html    | 51 ++++++++--------
 docs/_utils_8h_source.html         | 40 +++++++------
 docs/class_lattice-members.html    | 47 ++++++++-------
 docs/class_lattice.html            | 44 ++++++++++++--
 docs/class_lattice.js              |  3 +-
 docs/class_simulation-members.html | 37 ++++++------
 docs/class_simulation.html         | 12 ++--
 docs/class_simulation.js           |  3 +-
 docs/functions.html                | 13 +++-
 docs/functions_func.html           | 11 +++-
 docs/functions_vars.html           |  2 +-
 docs/index.html                    | 38 +++++++++++-
 docs/md__r_e_a_d_m_e.html          | 38 +++++++++++-
 docs/namespace_utils.html          | 30 +++++-----
 docs/namespacemembers.html         |  4 +-
 docs/namespacemembers_func.html    |  4 +-
 docs/navtreeindex0.js              | 96 ++++++++++++++++--------------
 docs/search/all_1.js               |  7 ++-
 docs/search/all_4.js               |  3 +-
 docs/search/all_6.js               |  2 +-
 docs/search/functions_1.js         |  6 +-
 docs/search/functions_4.js         |  1 +
 docs/search/functions_5.js         |  2 +-
 docs/search/variables_1.js         |  2 +-
 docs/struct_coords-members.html    |  2 +
 docs/struct_coords.html            | 62 ++++++++++++++++++-
 docs/struct_coords.js              |  2 +
 28 files changed, 403 insertions(+), 204 deletions(-)

diff --git a/docs/_lattice_8h_source.html b/docs/_lattice_8h_source.html
index f20d5fd..f744896 100644
--- a/docs/_lattice_8h_source.html
+++ b/docs/_lattice_8h_source.html
@@ -91,44 +91,45 @@
 <div class="title">Lattice.h</div>  </div>
 </div><!--header-->
 <div class="contents">
-<div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno">    1</span>&#160;<span class="comment">// Copyright (c) 2018 Michael C. Heiber</span></div><div class="line"><a name="l00002"></a><span class="lineno">    2</span>&#160;<span class="comment">// This source file is part of the KMC_Lattice project, which is subject to the MIT License.</span></div><div class="line"><a name="l00003"></a><span class="lineno">    3</span>&#160;<span class="comment">// For more information, see the LICENSE file that accompanies this software package.</span></div><div class="line"><a name="l00004"></a><span class="lineno">    4</span>&#160;<span class="comment">// The KMC_Lattice project can be found on Github at https://github.com/MikeHeiber/KMC_Lattice</span></div><div class="line"><a name="l00005"></a><span class="lineno">    5</span>&#160;</div><div class="line"><a name="l00006"></a><span class="lineno">    6</span>&#160;<span class="preprocessor">#ifndef LATTICE_H</span></div><div class="line"><a name="l00007"></a><span class="lineno">    7</span>&#160;<span class="preprocessor">#define LATTICE_H</span></div><div class="line"><a name="l00008"></a><span class="lineno">    8</span>&#160;</div><div class="line"><a name="l00009"></a><span class="lineno">    9</span>&#160;<span class="preprocessor">#include &quot;Utils.h&quot;</span></div><div class="line"><a name="l00010"></a><span class="lineno">   10</span>&#160;<span class="preprocessor">#include &quot;Site.h&quot;</span></div><div class="line"><a name="l00011"></a><span class="lineno">   11</span>&#160;<span class="preprocessor">#include &lt;functional&gt;</span></div><div class="line"><a name="l00012"></a><span class="lineno">   12</span>&#160;<span class="preprocessor">#include &lt;stdexcept&gt;</span></div><div class="line"><a name="l00013"></a><span class="lineno">   13</span>&#160;</div><div class="line"><a name="l00018"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html">   18</a></span>&#160;<span class="keyword">struct </span><a class="code" href="struct_parameters___lattice.html">Parameters_Lattice</a>{</div><div class="line"><a name="l00020"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html#a922f7e39f7debc0bd06ec1f0f1ca8257">   20</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___lattice.html#a922f7e39f7debc0bd06ec1f0f1ca8257">Enable_periodic_x</a>;</div><div class="line"><a name="l00022"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html#a9ee9c54330f7cd0bc32fd80e27ee87ff">   22</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___lattice.html#a9ee9c54330f7cd0bc32fd80e27ee87ff">Enable_periodic_y</a>;</div><div class="line"><a name="l00024"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html#aff375c434a37560067d9cc677cff8052">   24</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___lattice.html#aff375c434a37560067d9cc677cff8052">Enable_periodic_z</a>;</div><div class="line"><a name="l00026"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html#a99c7d553111bb660032bb7ca6f592da6">   26</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___lattice.html#a99c7d553111bb660032bb7ca6f592da6">Length</a>;</div><div class="line"><a name="l00028"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html#a40f8633b47d204f471d041a0d8216e5b">   28</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___lattice.html#a40f8633b47d204f471d041a0d8216e5b">Width</a>;</div><div class="line"><a name="l00030"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html#a1b59e1a307ad945fb86f44b68354f605">   30</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___lattice.html#a1b59e1a307ad945fb86f44b68354f605">Height</a>;</div><div class="line"><a name="l00032"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html#a5f9628b968ba4206a7650c774827b1f0">   32</a></span>&#160;    <span class="keywordtype">double</span> <a class="code" href="struct_parameters___lattice.html#a5f9628b968ba4206a7650c774827b1f0">Unit_size</a>; <span class="comment">// nm</span></div><div class="line"><a name="l00033"></a><span class="lineno">   33</span>&#160;};</div><div class="line"><a name="l00034"></a><span class="lineno">   34</span>&#160;</div><div class="line"><a name="l00041"></a><span class="lineno"><a class="line" href="class_lattice.html">   41</a></span>&#160;<span class="keyword">class </span><a class="code" href="class_lattice.html">Lattice</a>{</div><div class="line"><a name="l00042"></a><span class="lineno">   42</span>&#160;    <span class="keyword">public</span>:</div><div class="line"><a name="l00045"></a><span class="lineno">   45</span>&#160;        <a class="code" href="class_lattice.html#a70a5cebc3c0c5a0f609be0592e7cc117">Lattice</a>();</div><div class="line"><a name="l00046"></a><span class="lineno">   46</span>&#160;</div><div class="line"><a name="l00051"></a><span class="lineno">   51</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_lattice.html#a2b0a88048fae662aa71386a3a123a260">init</a>(<span class="keyword">const</span> <a class="code" href="struct_parameters___lattice.html">Parameters_Lattice</a>&amp; params, std::mt19937* generator_ptr);</div><div class="line"><a name="l00052"></a><span class="lineno">   52</span>&#160;</div><div class="line"><a name="l00062"></a><span class="lineno">   62</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_lattice.html#aa6b80d6264bfc23ae5fea39abd2557d5">calculateDestinationCoords</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_initial, <span class="keyword">const</span> <span class="keywordtype">int</span> i, <span class="keyword">const</span> <span class="keywordtype">int</span> j, <span class="keyword">const</span> <span class="keywordtype">int</span> k, <a class="code" href="struct_coords.html">Coords</a>&amp; coords_dest) <span class="keyword">const</span>;</div><div class="line"><a name="l00063"></a><span class="lineno">   63</span>&#160;</div><div class="line"><a name="l00070"></a><span class="lineno">   70</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a08adb2f412af409d3ec241e60e687c1a">calculateDX</a>(<span class="keyword">const</span> <span class="keywordtype">int</span> x, <span class="keyword">const</span> <span class="keywordtype">int</span> i) <span class="keyword">const</span>;</div><div class="line"><a name="l00071"></a><span class="lineno">   71</span>&#160;</div><div class="line"><a name="l00078"></a><span class="lineno">   78</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a08adb2f412af409d3ec241e60e687c1a">calculateDX</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_initial, <span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_dest) <span class="keyword">const</span>;</div><div class="line"><a name="l00079"></a><span class="lineno">   79</span>&#160;</div><div class="line"><a name="l00086"></a><span class="lineno">   86</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#acdeca889f7df11fe299f8b7941198c83">calculateDY</a>(<span class="keyword">const</span> <span class="keywordtype">int</span> y, <span class="keyword">const</span> <span class="keywordtype">int</span> j) <span class="keyword">const</span>;</div><div class="line"><a name="l00087"></a><span class="lineno">   87</span>&#160;</div><div class="line"><a name="l00094"></a><span class="lineno">   94</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#acdeca889f7df11fe299f8b7941198c83">calculateDY</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_initial, <span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_dest) <span class="keyword">const</span>;</div><div class="line"><a name="l00095"></a><span class="lineno">   95</span>&#160;</div><div class="line"><a name="l00102"></a><span class="lineno">  102</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a584ff9c528ebe46a6aea6ed652d107f4">calculateDZ</a>(<span class="keyword">const</span> <span class="keywordtype">int</span> z, <span class="keyword">const</span> <span class="keywordtype">int</span> k) <span class="keyword">const</span>;</div><div class="line"><a name="l00103"></a><span class="lineno">  103</span>&#160;</div><div class="line"><a name="l00110"></a><span class="lineno">  110</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a584ff9c528ebe46a6aea6ed652d107f4">calculateDZ</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_initial, <span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_dest) <span class="keyword">const</span>;</div><div class="line"><a name="l00111"></a><span class="lineno">  111</span>&#160;</div><div class="line"><a name="l00116"></a><span class="lineno">  116</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a3f51b0b41cf0e43e0469320310494a1e">calculateLatticeDistanceSquared</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_start, <span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_dest) <span class="keyword">const</span>;</div><div class="line"><a name="l00117"></a><span class="lineno">  117</span>&#160;</div><div class="line"><a name="l00127"></a><span class="lineno">  127</span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_lattice.html#ad0592298c4b92e9e84a768b95cd6d0f0">checkMoveValidity</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_initial, <span class="keyword">const</span> <span class="keywordtype">int</span> i, <span class="keyword">const</span> <span class="keywordtype">int</span> j, <span class="keyword">const</span> <span class="keywordtype">int</span> k) <span class="keyword">const</span>;</div><div class="line"><a name="l00128"></a><span class="lineno">  128</span>&#160;</div><div class="line"><a name="l00131"></a><span class="lineno">  131</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_lattice.html#a97a1b4f24cd40b81ed63aa2d7713b63b">clearOccupancy</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords);</div><div class="line"><a name="l00132"></a><span class="lineno">  132</span>&#160;</div><div class="line"><a name="l00135"></a><span class="lineno">  135</span>&#160;        <a class="code" href="struct_coords.html">Coords</a> <a class="code" href="class_lattice.html#a9fbb3c8bc23999ff685b6837beb62606">generateRandomCoords</a>();</div><div class="line"><a name="l00136"></a><span class="lineno">  136</span>&#160;</div><div class="line"><a name="l00140"></a><span class="lineno">  140</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#ab78435e50e3bf9f376c04fc305785bb4">generateRandomX</a>();</div><div class="line"><a name="l00141"></a><span class="lineno">  141</span>&#160;</div><div class="line"><a name="l00145"></a><span class="lineno">  145</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a180a9d79a40b1a0a092c8ab489569700">generateRandomY</a>();</div><div class="line"><a name="l00146"></a><span class="lineno">  146</span>&#160;</div><div class="line"><a name="l00150"></a><span class="lineno">  150</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a96006397a6ab389fb1eee87fde6e2165">generateRandomZ</a>();</div><div class="line"><a name="l00151"></a><span class="lineno">  151</span>&#160;</div><div class="line"><a name="l00154"></a><span class="lineno">  154</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#aaa0cba3ab33ac620d9b9f9508c56d1ac">getHeight</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00155"></a><span class="lineno">  155</span>&#160;</div><div class="line"><a name="l00158"></a><span class="lineno">  158</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a4b43b67a36fcd3dfe62c9eeaffa561d2">getLength</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00159"></a><span class="lineno">  159</span>&#160;</div><div class="line"><a name="l00162"></a><span class="lineno">  162</span>&#160;        <span class="keywordtype">long</span> <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a4be17e9123f7737387991a9d1a8b87b3">getNumSites</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00163"></a><span class="lineno">  163</span>&#160;</div><div class="line"><a name="l00167"></a><span class="lineno">  167</span>&#160;        <a class="code" href="struct_coords.html">Coords</a> <a class="code" href="class_lattice.html#a74a170b841ad1b74dad43519d37e9eaf">getSiteCoords</a>(<span class="keywordtype">long</span> <span class="keywordtype">int</span> site_index);</div><div class="line"><a name="l00168"></a><span class="lineno">  168</span>&#160;</div><div class="line"><a name="l00173"></a><span class="lineno">  173</span>&#160;        <span class="keywordtype">long</span> <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a60431f6504a253d47acb0b02f524571c">getSiteIndex</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords) <span class="keyword">const</span>;</div><div class="line"><a name="l00174"></a><span class="lineno">  174</span>&#160;</div><div class="line"><a name="l00178"></a><span class="lineno">  178</span>&#160;        std::vector&lt;Site*&gt;::iterator <a class="code" href="class_lattice.html#a46f7d12855d24e1bdd02814621b0a178">getSiteIt</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords);</div><div class="line"><a name="l00179"></a><span class="lineno">  179</span>&#160;</div><div class="line"><a name="l00182"></a><span class="lineno">  182</span>&#160;        <span class="keywordtype">double</span> <a class="code" href="class_lattice.html#ac6963a6b2b4b8d96d3417f6e9c2a509d">getUnitSize</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00183"></a><span class="lineno">  183</span>&#160;</div><div class="line"><a name="l00185"></a><span class="lineno">  185</span>&#160;        <span class="keywordtype">double</span> <a class="code" href="class_lattice.html#a46f9cec33419459b64ff0efdf47a38b9">getVolume</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00186"></a><span class="lineno">  186</span>&#160;</div><div class="line"><a name="l00189"></a><span class="lineno">  189</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#aeb60d2b8bfb02d9da8bef463f0d41428">getWidth</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00190"></a><span class="lineno">  190</span>&#160;</div><div class="line"><a name="l00195"></a><span class="lineno">  195</span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_lattice.html#a4d37afb6ad4c67f4f6462c2f6d5c337d">isOccupied</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords) <span class="keyword">const</span>;</div><div class="line"><a name="l00196"></a><span class="lineno">  196</span>&#160;</div><div class="line"><a name="l00200"></a><span class="lineno">  200</span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_lattice.html#accf3b995e0d0cb422907728a29b1b523">isXPeriodic</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00201"></a><span class="lineno">  201</span>&#160;</div><div class="line"><a name="l00205"></a><span class="lineno">  205</span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_lattice.html#ac3192acefb019c5258143a6c758b3e48">isYPeriodic</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00206"></a><span class="lineno">  206</span>&#160;</div><div class="line"><a name="l00210"></a><span class="lineno">  210</span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_lattice.html#ad7dd1b12a253e506aba5cedb57bf86ea">isZPeriodic</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00211"></a><span class="lineno">  211</span>&#160;</div><div class="line"><a name="l00213"></a><span class="lineno">  213</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_lattice.html#aa1f65735ecbd750ec04b6413b4d47316">outputLatticeOccupancy</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00214"></a><span class="lineno">  214</span>&#160;</div><div class="line"><a name="l00217"></a><span class="lineno">  217</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_lattice.html#a515b8bc548ef4a87c3495a7352a60399">setOccupied</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords);</div><div class="line"><a name="l00218"></a><span class="lineno">  218</span>&#160;</div><div class="line"><a name="l00223"></a><span class="lineno">  223</span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_lattice.html#a59546ec4301871897ba5adfda1126741">setSitePointers</a>(<span class="keyword">const</span> std::vector&lt;Site*&gt;&amp; input_ptrs);</div><div class="line"><a name="l00224"></a><span class="lineno">  224</span>&#160;    <span class="keyword">protected</span>:</div><div class="line"><a name="l00225"></a><span class="lineno">  225</span>&#160;</div><div class="line"><a name="l00226"></a><span class="lineno">  226</span>&#160;    <span class="keyword">private</span>:</div><div class="line"><a name="l00227"></a><span class="lineno">  227</span>&#160;        <span class="keywordtype">bool</span> Enable_periodic_x;</div><div class="line"><a name="l00228"></a><span class="lineno">  228</span>&#160;        <span class="keywordtype">bool</span> Enable_periodic_y;</div><div class="line"><a name="l00229"></a><span class="lineno">  229</span>&#160;        <span class="keywordtype">bool</span> Enable_periodic_z;</div><div class="line"><a name="l00230"></a><span class="lineno">  230</span>&#160;        <span class="keywordtype">int</span> Length; <span class="comment">// nm</span></div><div class="line"><a name="l00231"></a><span class="lineno">  231</span>&#160;        <span class="keywordtype">int</span> Width; <span class="comment">// nm</span></div><div class="line"><a name="l00232"></a><span class="lineno">  232</span>&#160;        <span class="keywordtype">int</span> Height; <span class="comment">// nm</span></div><div class="line"><a name="l00233"></a><span class="lineno">  233</span>&#160;        <span class="keywordtype">double</span> Unit_size; <span class="comment">// nm</span></div><div class="line"><a name="l00234"></a><span class="lineno">  234</span>&#160;        std::vector&lt;Site*&gt; site_ptrs;</div><div class="line"><a name="l00235"></a><span class="lineno">  235</span>&#160;        std::mt19937* gen_ptr;</div><div class="line"><a name="l00236"></a><span class="lineno">  236</span>&#160;};</div><div class="line"><a name="l00237"></a><span class="lineno">  237</span>&#160;</div><div class="line"><a name="l00238"></a><span class="lineno">  238</span>&#160;<span class="preprocessor">#endif // LATTICE_H</span></div><div class="ttc" id="class_lattice_html_a96006397a6ab389fb1eee87fde6e2165"><div class="ttname"><a href="class_lattice.html#a96006397a6ab389fb1eee87fde6e2165">Lattice::generateRandomZ</a></div><div class="ttdeci">int generateRandomZ()</div><div class="ttdoc">Generates a random z coordinate that lies within the z-dimension size of the lattice. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:171</div></div>
-<div class="ttc" id="class_lattice_html_a59546ec4301871897ba5adfda1126741"><div class="ttname"><a href="class_lattice.html#a59546ec4301871897ba5adfda1126741">Lattice::setSitePointers</a></div><div class="ttdeci">bool setSitePointers(const std::vector&lt; Site *&gt; &amp;input_ptrs)</div><div class="ttdoc">Sets the member site pointer vector to the input site pointer vector. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:258</div></div>
-<div class="ttc" id="class_lattice_html_a4d37afb6ad4c67f4f6462c2f6d5c337d"><div class="ttname"><a href="class_lattice.html#a4d37afb6ad4c67f4f6462c2f6d5c337d">Lattice::isOccupied</a></div><div class="ttdeci">bool isOccupied(const Coords &amp;coords) const</div><div class="ttdoc">Checks whether the site located at the input coordinates is occupied or not. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:230</div></div>
+<div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno">    1</span>&#160;<span class="comment">// Copyright (c) 2018 Michael C. Heiber</span></div><div class="line"><a name="l00002"></a><span class="lineno">    2</span>&#160;<span class="comment">// This source file is part of the KMC_Lattice project, which is subject to the MIT License.</span></div><div class="line"><a name="l00003"></a><span class="lineno">    3</span>&#160;<span class="comment">// For more information, see the LICENSE file that accompanies this software package.</span></div><div class="line"><a name="l00004"></a><span class="lineno">    4</span>&#160;<span class="comment">// The KMC_Lattice project can be found on Github at https://github.com/MikeHeiber/KMC_Lattice</span></div><div class="line"><a name="l00005"></a><span class="lineno">    5</span>&#160;</div><div class="line"><a name="l00006"></a><span class="lineno">    6</span>&#160;<span class="preprocessor">#ifndef LATTICE_H</span></div><div class="line"><a name="l00007"></a><span class="lineno">    7</span>&#160;<span class="preprocessor">#define LATTICE_H</span></div><div class="line"><a name="l00008"></a><span class="lineno">    8</span>&#160;</div><div class="line"><a name="l00009"></a><span class="lineno">    9</span>&#160;<span class="preprocessor">#include &quot;Utils.h&quot;</span></div><div class="line"><a name="l00010"></a><span class="lineno">   10</span>&#160;<span class="preprocessor">#include &quot;Site.h&quot;</span></div><div class="line"><a name="l00011"></a><span class="lineno">   11</span>&#160;<span class="preprocessor">#include &lt;functional&gt;</span></div><div class="line"><a name="l00012"></a><span class="lineno">   12</span>&#160;<span class="preprocessor">#include &lt;stdexcept&gt;</span></div><div class="line"><a name="l00013"></a><span class="lineno">   13</span>&#160;</div><div class="line"><a name="l00018"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html">   18</a></span>&#160;<span class="keyword">struct </span><a class="code" href="struct_parameters___lattice.html">Parameters_Lattice</a>{</div><div class="line"><a name="l00020"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html#a922f7e39f7debc0bd06ec1f0f1ca8257">   20</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___lattice.html#a922f7e39f7debc0bd06ec1f0f1ca8257">Enable_periodic_x</a>;</div><div class="line"><a name="l00022"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html#a9ee9c54330f7cd0bc32fd80e27ee87ff">   22</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___lattice.html#a9ee9c54330f7cd0bc32fd80e27ee87ff">Enable_periodic_y</a>;</div><div class="line"><a name="l00024"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html#aff375c434a37560067d9cc677cff8052">   24</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___lattice.html#aff375c434a37560067d9cc677cff8052">Enable_periodic_z</a>;</div><div class="line"><a name="l00026"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html#a99c7d553111bb660032bb7ca6f592da6">   26</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___lattice.html#a99c7d553111bb660032bb7ca6f592da6">Length</a>;</div><div class="line"><a name="l00028"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html#a40f8633b47d204f471d041a0d8216e5b">   28</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___lattice.html#a40f8633b47d204f471d041a0d8216e5b">Width</a>;</div><div class="line"><a name="l00030"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html#a1b59e1a307ad945fb86f44b68354f605">   30</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___lattice.html#a1b59e1a307ad945fb86f44b68354f605">Height</a>;</div><div class="line"><a name="l00032"></a><span class="lineno"><a class="line" href="struct_parameters___lattice.html#a5f9628b968ba4206a7650c774827b1f0">   32</a></span>&#160;    <span class="keywordtype">double</span> <a class="code" href="struct_parameters___lattice.html#a5f9628b968ba4206a7650c774827b1f0">Unit_size</a>; <span class="comment">// nm</span></div><div class="line"><a name="l00033"></a><span class="lineno">   33</span>&#160;};</div><div class="line"><a name="l00034"></a><span class="lineno">   34</span>&#160;</div><div class="line"><a name="l00041"></a><span class="lineno"><a class="line" href="class_lattice.html">   41</a></span>&#160;<span class="keyword">class </span><a class="code" href="class_lattice.html">Lattice</a>{</div><div class="line"><a name="l00042"></a><span class="lineno">   42</span>&#160;    <span class="keyword">public</span>:</div><div class="line"><a name="l00045"></a><span class="lineno">   45</span>&#160;        <a class="code" href="class_lattice.html#a70a5cebc3c0c5a0f609be0592e7cc117">Lattice</a>();</div><div class="line"><a name="l00046"></a><span class="lineno">   46</span>&#160;</div><div class="line"><a name="l00051"></a><span class="lineno">   51</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_lattice.html#ab7322e5340badb9df4d208554fd90a89">init</a>(<span class="keyword">const</span> <a class="code" href="struct_parameters___lattice.html">Parameters_Lattice</a>&amp; params, std::mt19937_64* generator_ptr);</div><div class="line"><a name="l00052"></a><span class="lineno">   52</span>&#160;</div><div class="line"><a name="l00062"></a><span class="lineno">   62</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_lattice.html#aa6b80d6264bfc23ae5fea39abd2557d5">calculateDestinationCoords</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_initial, <span class="keyword">const</span> <span class="keywordtype">int</span> i, <span class="keyword">const</span> <span class="keywordtype">int</span> j, <span class="keyword">const</span> <span class="keywordtype">int</span> k, <a class="code" href="struct_coords.html">Coords</a>&amp; coords_dest) <span class="keyword">const</span>;</div><div class="line"><a name="l00063"></a><span class="lineno">   63</span>&#160;</div><div class="line"><a name="l00070"></a><span class="lineno">   70</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a08adb2f412af409d3ec241e60e687c1a">calculateDX</a>(<span class="keyword">const</span> <span class="keywordtype">int</span> x, <span class="keyword">const</span> <span class="keywordtype">int</span> i) <span class="keyword">const</span>;</div><div class="line"><a name="l00071"></a><span class="lineno">   71</span>&#160;</div><div class="line"><a name="l00078"></a><span class="lineno">   78</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a08adb2f412af409d3ec241e60e687c1a">calculateDX</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_initial, <span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_dest) <span class="keyword">const</span>;</div><div class="line"><a name="l00079"></a><span class="lineno">   79</span>&#160;</div><div class="line"><a name="l00086"></a><span class="lineno">   86</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#acdeca889f7df11fe299f8b7941198c83">calculateDY</a>(<span class="keyword">const</span> <span class="keywordtype">int</span> y, <span class="keyword">const</span> <span class="keywordtype">int</span> j) <span class="keyword">const</span>;</div><div class="line"><a name="l00087"></a><span class="lineno">   87</span>&#160;</div><div class="line"><a name="l00094"></a><span class="lineno">   94</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#acdeca889f7df11fe299f8b7941198c83">calculateDY</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_initial, <span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_dest) <span class="keyword">const</span>;</div><div class="line"><a name="l00095"></a><span class="lineno">   95</span>&#160;</div><div class="line"><a name="l00102"></a><span class="lineno">  102</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a584ff9c528ebe46a6aea6ed652d107f4">calculateDZ</a>(<span class="keyword">const</span> <span class="keywordtype">int</span> z, <span class="keyword">const</span> <span class="keywordtype">int</span> k) <span class="keyword">const</span>;</div><div class="line"><a name="l00103"></a><span class="lineno">  103</span>&#160;</div><div class="line"><a name="l00110"></a><span class="lineno">  110</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a584ff9c528ebe46a6aea6ed652d107f4">calculateDZ</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_initial, <span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_dest) <span class="keyword">const</span>;</div><div class="line"><a name="l00111"></a><span class="lineno">  111</span>&#160;</div><div class="line"><a name="l00116"></a><span class="lineno">  116</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a3f51b0b41cf0e43e0469320310494a1e">calculateLatticeDistanceSquared</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_start, <span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_dest) <span class="keyword">const</span>;</div><div class="line"><a name="l00117"></a><span class="lineno">  117</span>&#160;</div><div class="line"><a name="l00127"></a><span class="lineno">  127</span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_lattice.html#ad0592298c4b92e9e84a768b95cd6d0f0">checkMoveValidity</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_initial, <span class="keyword">const</span> <span class="keywordtype">int</span> i, <span class="keyword">const</span> <span class="keywordtype">int</span> j, <span class="keyword">const</span> <span class="keywordtype">int</span> k) <span class="keyword">const</span>;</div><div class="line"><a name="l00128"></a><span class="lineno">  128</span>&#160;</div><div class="line"><a name="l00134"></a><span class="lineno">  134</span>&#160;        <a class="code" href="struct_coords.html">Coords</a> <a class="code" href="class_lattice.html#abf954e8213010ab8aeac7a0b93a869bc">chooseRandomUnoccupiedNeighbor</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_i);</div><div class="line"><a name="l00135"></a><span class="lineno">  135</span>&#160;</div><div class="line"><a name="l00138"></a><span class="lineno">  138</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_lattice.html#a97a1b4f24cd40b81ed63aa2d7713b63b">clearOccupancy</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords);</div><div class="line"><a name="l00139"></a><span class="lineno">  139</span>&#160;</div><div class="line"><a name="l00142"></a><span class="lineno">  142</span>&#160;        <a class="code" href="struct_coords.html">Coords</a> <a class="code" href="class_lattice.html#a9fbb3c8bc23999ff685b6837beb62606">generateRandomCoords</a>();</div><div class="line"><a name="l00143"></a><span class="lineno">  143</span>&#160;</div><div class="line"><a name="l00147"></a><span class="lineno">  147</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#ab78435e50e3bf9f376c04fc305785bb4">generateRandomX</a>();</div><div class="line"><a name="l00148"></a><span class="lineno">  148</span>&#160;</div><div class="line"><a name="l00152"></a><span class="lineno">  152</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a180a9d79a40b1a0a092c8ab489569700">generateRandomY</a>();</div><div class="line"><a name="l00153"></a><span class="lineno">  153</span>&#160;</div><div class="line"><a name="l00157"></a><span class="lineno">  157</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a96006397a6ab389fb1eee87fde6e2165">generateRandomZ</a>();</div><div class="line"><a name="l00158"></a><span class="lineno">  158</span>&#160;</div><div class="line"><a name="l00161"></a><span class="lineno">  161</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#aaa0cba3ab33ac620d9b9f9508c56d1ac">getHeight</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00162"></a><span class="lineno">  162</span>&#160;</div><div class="line"><a name="l00165"></a><span class="lineno">  165</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a4b43b67a36fcd3dfe62c9eeaffa561d2">getLength</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00166"></a><span class="lineno">  166</span>&#160;</div><div class="line"><a name="l00169"></a><span class="lineno">  169</span>&#160;        <span class="keywordtype">long</span> <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a4be17e9123f7737387991a9d1a8b87b3">getNumSites</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00170"></a><span class="lineno">  170</span>&#160;</div><div class="line"><a name="l00174"></a><span class="lineno">  174</span>&#160;        <a class="code" href="struct_coords.html">Coords</a> <a class="code" href="class_lattice.html#a74a170b841ad1b74dad43519d37e9eaf">getSiteCoords</a>(<span class="keywordtype">long</span> <span class="keywordtype">int</span> site_index);</div><div class="line"><a name="l00175"></a><span class="lineno">  175</span>&#160;</div><div class="line"><a name="l00180"></a><span class="lineno">  180</span>&#160;        <span class="keywordtype">long</span> <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#a60431f6504a253d47acb0b02f524571c">getSiteIndex</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords) <span class="keyword">const</span>;</div><div class="line"><a name="l00181"></a><span class="lineno">  181</span>&#160;</div><div class="line"><a name="l00185"></a><span class="lineno">  185</span>&#160;        std::vector&lt;Site*&gt;::iterator <a class="code" href="class_lattice.html#a46f7d12855d24e1bdd02814621b0a178">getSiteIt</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords);</div><div class="line"><a name="l00186"></a><span class="lineno">  186</span>&#160;</div><div class="line"><a name="l00189"></a><span class="lineno">  189</span>&#160;        <span class="keywordtype">double</span> <a class="code" href="class_lattice.html#ac6963a6b2b4b8d96d3417f6e9c2a509d">getUnitSize</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00190"></a><span class="lineno">  190</span>&#160;</div><div class="line"><a name="l00192"></a><span class="lineno">  192</span>&#160;        <span class="keywordtype">double</span> <a class="code" href="class_lattice.html#a46f9cec33419459b64ff0efdf47a38b9">getVolume</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00193"></a><span class="lineno">  193</span>&#160;</div><div class="line"><a name="l00196"></a><span class="lineno">  196</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_lattice.html#aeb60d2b8bfb02d9da8bef463f0d41428">getWidth</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00197"></a><span class="lineno">  197</span>&#160;</div><div class="line"><a name="l00202"></a><span class="lineno">  202</span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_lattice.html#a4d37afb6ad4c67f4f6462c2f6d5c337d">isOccupied</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords) <span class="keyword">const</span>;</div><div class="line"><a name="l00203"></a><span class="lineno">  203</span>&#160;</div><div class="line"><a name="l00207"></a><span class="lineno">  207</span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_lattice.html#accf3b995e0d0cb422907728a29b1b523">isXPeriodic</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00208"></a><span class="lineno">  208</span>&#160;</div><div class="line"><a name="l00212"></a><span class="lineno">  212</span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_lattice.html#ac3192acefb019c5258143a6c758b3e48">isYPeriodic</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00213"></a><span class="lineno">  213</span>&#160;</div><div class="line"><a name="l00217"></a><span class="lineno">  217</span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_lattice.html#ad7dd1b12a253e506aba5cedb57bf86ea">isZPeriodic</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00218"></a><span class="lineno">  218</span>&#160;</div><div class="line"><a name="l00220"></a><span class="lineno">  220</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_lattice.html#aa1f65735ecbd750ec04b6413b4d47316">outputLatticeOccupancy</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00221"></a><span class="lineno">  221</span>&#160;</div><div class="line"><a name="l00224"></a><span class="lineno">  224</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_lattice.html#a515b8bc548ef4a87c3495a7352a60399">setOccupied</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords);</div><div class="line"><a name="l00225"></a><span class="lineno">  225</span>&#160;</div><div class="line"><a name="l00230"></a><span class="lineno">  230</span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_lattice.html#a59546ec4301871897ba5adfda1126741">setSitePointers</a>(<span class="keyword">const</span> std::vector&lt;Site*&gt;&amp; input_ptrs);</div><div class="line"><a name="l00231"></a><span class="lineno">  231</span>&#160;    <span class="keyword">protected</span>:</div><div class="line"><a name="l00232"></a><span class="lineno">  232</span>&#160;</div><div class="line"><a name="l00233"></a><span class="lineno">  233</span>&#160;    <span class="keyword">private</span>:</div><div class="line"><a name="l00234"></a><span class="lineno">  234</span>&#160;        <span class="keywordtype">bool</span> Enable_periodic_x;</div><div class="line"><a name="l00235"></a><span class="lineno">  235</span>&#160;        <span class="keywordtype">bool</span> Enable_periodic_y;</div><div class="line"><a name="l00236"></a><span class="lineno">  236</span>&#160;        <span class="keywordtype">bool</span> Enable_periodic_z;</div><div class="line"><a name="l00237"></a><span class="lineno">  237</span>&#160;        <span class="keywordtype">int</span> Length; <span class="comment">// nm</span></div><div class="line"><a name="l00238"></a><span class="lineno">  238</span>&#160;        <span class="keywordtype">int</span> Width; <span class="comment">// nm</span></div><div class="line"><a name="l00239"></a><span class="lineno">  239</span>&#160;        <span class="keywordtype">int</span> Height; <span class="comment">// nm</span></div><div class="line"><a name="l00240"></a><span class="lineno">  240</span>&#160;        <span class="keywordtype">double</span> Unit_size; <span class="comment">// nm</span></div><div class="line"><a name="l00241"></a><span class="lineno">  241</span>&#160;        std::vector&lt;Site*&gt; site_ptrs;</div><div class="line"><a name="l00242"></a><span class="lineno">  242</span>&#160;        std::mt19937_64* gen_ptr;</div><div class="line"><a name="l00243"></a><span class="lineno">  243</span>&#160;};</div><div class="line"><a name="l00244"></a><span class="lineno">  244</span>&#160;</div><div class="line"><a name="l00245"></a><span class="lineno">  245</span>&#160;<span class="preprocessor">#endif // LATTICE_H</span></div><div class="ttc" id="class_lattice_html_a96006397a6ab389fb1eee87fde6e2165"><div class="ttname"><a href="class_lattice.html#a96006397a6ab389fb1eee87fde6e2165">Lattice::generateRandomZ</a></div><div class="ttdeci">int generateRandomZ()</div><div class="ttdoc">Generates a random z coordinate that lies within the z-dimension size of the lattice. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:215</div></div>
+<div class="ttc" id="class_lattice_html_a59546ec4301871897ba5adfda1126741"><div class="ttname"><a href="class_lattice.html#a59546ec4301871897ba5adfda1126741">Lattice::setSitePointers</a></div><div class="ttdeci">bool setSitePointers(const std::vector&lt; Site *&gt; &amp;input_ptrs)</div><div class="ttdoc">Sets the member site pointer vector to the input site pointer vector. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:301</div></div>
+<div class="ttc" id="class_lattice_html_a4d37afb6ad4c67f4f6462c2f6d5c337d"><div class="ttname"><a href="class_lattice.html#a4d37afb6ad4c67f4f6462c2f6d5c337d">Lattice::isOccupied</a></div><div class="ttdeci">bool isOccupied(const Coords &amp;coords) const</div><div class="ttdoc">Checks whether the site located at the input coordinates is occupied or not. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:273</div></div>
 <div class="ttc" id="class_lattice_html_a584ff9c528ebe46a6aea6ed652d107f4"><div class="ttname"><a href="class_lattice.html#a584ff9c528ebe46a6aea6ed652d107f4">Lattice::calculateDZ</a></div><div class="ttdeci">int calculateDZ(const int z, const int k) const</div><div class="ttdoc">Calculates a coordinate adjustment factor if the z-direction periodic boundary is crossed...</div><div class="ttdef"><b>Definition:</b> Lattice.cpp:81</div></div>
 <div class="ttc" id="struct_parameters___lattice_html_a922f7e39f7debc0bd06ec1f0f1ca8257"><div class="ttname"><a href="struct_parameters___lattice.html#a922f7e39f7debc0bd06ec1f0f1ca8257">Parameters_Lattice::Enable_periodic_x</a></div><div class="ttdeci">bool Enable_periodic_x</div><div class="ttdoc">Determines whether the x-direction periodic boundaries will be enabled. </div><div class="ttdef"><b>Definition:</b> Lattice.h:20</div></div>
-<div class="ttc" id="class_lattice_html_a180a9d79a40b1a0a092c8ab489569700"><div class="ttname"><a href="class_lattice.html#a180a9d79a40b1a0a092c8ab489569700">Lattice::generateRandomY</a></div><div class="ttdeci">int generateRandomY()</div><div class="ttdoc">Generates a random y coordinate that lies within the y-dimension size of the lattice. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:165</div></div>
+<div class="ttc" id="class_lattice_html_a180a9d79a40b1a0a092c8ab489569700"><div class="ttname"><a href="class_lattice.html#a180a9d79a40b1a0a092c8ab489569700">Lattice::generateRandomY</a></div><div class="ttdeci">int generateRandomY()</div><div class="ttdoc">Generates a random y coordinate that lies within the y-dimension size of the lattice. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:210</div></div>
 <div class="ttc" id="class_lattice_html_acdeca889f7df11fe299f8b7941198c83"><div class="ttname"><a href="class_lattice.html#acdeca889f7df11fe299f8b7941198c83">Lattice::calculateDY</a></div><div class="ttdeci">int calculateDY(const int y, const int j) const</div><div class="ttdoc">Calculates a coordinate adjustment factor if the y-direction periodic boundary is crossed...</div><div class="ttdef"><b>Definition:</b> Lattice.cpp:57</div></div>
 <div class="ttc" id="struct_parameters___lattice_html_a9ee9c54330f7cd0bc32fd80e27ee87ff"><div class="ttname"><a href="struct_parameters___lattice.html#a9ee9c54330f7cd0bc32fd80e27ee87ff">Parameters_Lattice::Enable_periodic_y</a></div><div class="ttdeci">bool Enable_periodic_y</div><div class="ttdoc">Determines whether the y-direction periodic boundaries will be enabled. </div><div class="ttdef"><b>Definition:</b> Lattice.h:22</div></div>
 <div class="ttc" id="class_lattice_html_a70a5cebc3c0c5a0f609be0592e7cc117"><div class="ttname"><a href="class_lattice.html#a70a5cebc3c0c5a0f609be0592e7cc117">Lattice::Lattice</a></div><div class="ttdeci">Lattice()</div><div class="ttdoc">Default constructor that creates an empty Lattice object. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:11</div></div>
 <div class="ttc" id="class_lattice_html_aa6b80d6264bfc23ae5fea39abd2557d5"><div class="ttname"><a href="class_lattice.html#aa6b80d6264bfc23ae5fea39abd2557d5">Lattice::calculateDestinationCoords</a></div><div class="ttdeci">void calculateDestinationCoords(const Coords &amp;coords_initial, const int i, const int j, const int k, Coords &amp;coords_dest) const</div><div class="ttdoc">Calculates the destination coordinates when given the starting coordinates and the displacement vecto...</div><div class="ttdef"><b>Definition:</b> Lattice.cpp:27</div></div>
-<div class="ttc" id="class_lattice_html_ac6963a6b2b4b8d96d3417f6e9c2a509d"><div class="ttname"><a href="class_lattice.html#ac6963a6b2b4b8d96d3417f6e9c2a509d">Lattice::getUnitSize</a></div><div class="ttdeci">double getUnitSize() const</div><div class="ttdoc">Gets the lattice unit size, which is used to convert lattice units into real space units...</div><div class="ttdef"><b>Definition:</b> Lattice.cpp:218</div></div>
-<div class="ttc" id="class_lattice_html_a2b0a88048fae662aa71386a3a123a260"><div class="ttname"><a href="class_lattice.html#a2b0a88048fae662aa71386a3a123a260">Lattice::init</a></div><div class="ttdeci">void init(const Parameters_Lattice &amp;params, std::mt19937 *generator_ptr)</div><div class="ttdoc">Initializes the Lattice object using the provided Parameters_Lattice input parameter struct...</div><div class="ttdef"><b>Definition:</b> Lattice.cpp:15</div></div>
-<div class="ttc" id="class_lattice_html_ab78435e50e3bf9f376c04fc305785bb4"><div class="ttname"><a href="class_lattice.html#ab78435e50e3bf9f376c04fc305785bb4">Lattice::generateRandomX</a></div><div class="ttdeci">int generateRandomX()</div><div class="ttdoc">Generates a random x coordinate that lies within the x-dimension size of the lattice. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:159</div></div>
-<div class="ttc" id="class_lattice_html_a74a170b841ad1b74dad43519d37e9eaf"><div class="ttname"><a href="class_lattice.html#a74a170b841ad1b74dad43519d37e9eaf">Lattice::getSiteCoords</a></div><div class="ttdeci">Coords getSiteCoords(long int site_index)</div><div class="ttdoc">Gets the coordinates of the specified site. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:189</div></div>
-<div class="ttc" id="class_lattice_html_a515b8bc548ef4a87c3495a7352a60399"><div class="ttname"><a href="class_lattice.html#a515b8bc548ef4a87c3495a7352a60399">Lattice::setOccupied</a></div><div class="ttdeci">void setOccupied(const Coords &amp;coords)</div><div class="ttdoc">Sets the site located at the input coordinates to the occupied state. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:254</div></div>
+<div class="ttc" id="class_lattice_html_ac6963a6b2b4b8d96d3417f6e9c2a509d"><div class="ttname"><a href="class_lattice.html#ac6963a6b2b4b8d96d3417f6e9c2a509d">Lattice::getUnitSize</a></div><div class="ttdeci">double getUnitSize() const</div><div class="ttdoc">Gets the lattice unit size, which is used to convert lattice units into real space units...</div><div class="ttdef"><b>Definition:</b> Lattice.cpp:261</div></div>
+<div class="ttc" id="class_lattice_html_ab78435e50e3bf9f376c04fc305785bb4"><div class="ttname"><a href="class_lattice.html#ab78435e50e3bf9f376c04fc305785bb4">Lattice::generateRandomX</a></div><div class="ttdeci">int generateRandomX()</div><div class="ttdoc">Generates a random x coordinate that lies within the x-dimension size of the lattice. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:205</div></div>
+<div class="ttc" id="class_lattice_html_a74a170b841ad1b74dad43519d37e9eaf"><div class="ttname"><a href="class_lattice.html#a74a170b841ad1b74dad43519d37e9eaf">Lattice::getSiteCoords</a></div><div class="ttdeci">Coords getSiteCoords(long int site_index)</div><div class="ttdoc">Gets the coordinates of the specified site. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:232</div></div>
+<div class="ttc" id="class_lattice_html_a515b8bc548ef4a87c3495a7352a60399"><div class="ttname"><a href="class_lattice.html#a515b8bc548ef4a87c3495a7352a60399">Lattice::setOccupied</a></div><div class="ttdeci">void setOccupied(const Coords &amp;coords)</div><div class="ttdoc">Sets the site located at the input coordinates to the occupied state. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:297</div></div>
 <div class="ttc" id="class_lattice_html_a3f51b0b41cf0e43e0469320310494a1e"><div class="ttname"><a href="class_lattice.html#a3f51b0b41cf0e43e0469320310494a1e">Lattice::calculateLatticeDistanceSquared</a></div><div class="ttdeci">int calculateLatticeDistanceSquared(const Coords &amp;coords_start, const Coords &amp;coords_dest) const</div><div class="ttdoc">Calculates the shortest distance between a pair of coordinates in squared lattice units...</div><div class="ttdef"><b>Definition:</b> Lattice.cpp:105</div></div>
-<div class="ttc" id="class_lattice_html_ac3192acefb019c5258143a6c758b3e48"><div class="ttname"><a href="class_lattice.html#ac3192acefb019c5258143a6c758b3e48">Lattice::isYPeriodic</a></div><div class="ttdeci">bool isYPeriodic() const</div><div class="ttdoc">Checks whether the y-direction periodic boundaries are enabled or not. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:238</div></div>
-<div class="ttc" id="class_lattice_html_a60431f6504a253d47acb0b02f524571c"><div class="ttname"><a href="class_lattice.html#a60431f6504a253d47acb0b02f524571c">Lattice::getSiteIndex</a></div><div class="ttdeci">long int getSiteIndex(const Coords &amp;coords) const</div><div class="ttdoc">Gets the vector index for the site corresponding to the input coordinates. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:202</div></div>
+<div class="ttc" id="class_lattice_html_ac3192acefb019c5258143a6c758b3e48"><div class="ttname"><a href="class_lattice.html#ac3192acefb019c5258143a6c758b3e48">Lattice::isYPeriodic</a></div><div class="ttdeci">bool isYPeriodic() const</div><div class="ttdoc">Checks whether the y-direction periodic boundaries are enabled or not. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:281</div></div>
+<div class="ttc" id="class_lattice_html_a60431f6504a253d47acb0b02f524571c"><div class="ttname"><a href="class_lattice.html#a60431f6504a253d47acb0b02f524571c">Lattice::getSiteIndex</a></div><div class="ttdeci">long int getSiteIndex(const Coords &amp;coords) const</div><div class="ttdoc">Gets the vector index for the site corresponding to the input coordinates. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:245</div></div>
 <div class="ttc" id="struct_parameters___lattice_html_aff375c434a37560067d9cc677cff8052"><div class="ttname"><a href="struct_parameters___lattice.html#aff375c434a37560067d9cc677cff8052">Parameters_Lattice::Enable_periodic_z</a></div><div class="ttdeci">bool Enable_periodic_z</div><div class="ttdoc">Determines whether the z-direction periodic boundaries will be enabled. </div><div class="ttdef"><b>Definition:</b> Lattice.h:24</div></div>
-<div class="ttc" id="class_lattice_html_aaa0cba3ab33ac620d9b9f9508c56d1ac"><div class="ttname"><a href="class_lattice.html#aaa0cba3ab33ac620d9b9f9508c56d1ac">Lattice::getHeight</a></div><div class="ttdeci">int getHeight() const</div><div class="ttdoc">Gets the z-direction size of the lattice, the height. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:177</div></div>
+<div class="ttc" id="class_lattice_html_aaa0cba3ab33ac620d9b9f9508c56d1ac"><div class="ttname"><a href="class_lattice.html#aaa0cba3ab33ac620d9b9f9508c56d1ac">Lattice::getHeight</a></div><div class="ttdeci">int getHeight() const</div><div class="ttdoc">Gets the z-direction size of the lattice, the height. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:220</div></div>
 <div class="ttc" id="struct_parameters___lattice_html"><div class="ttname"><a href="struct_parameters___lattice.html">Parameters_Lattice</a></div><div class="ttdoc">This struct contains all of the main input parameters needed by the Lattice class. </div><div class="ttdef"><b>Definition:</b> Lattice.h:18</div></div>
+<div class="ttc" id="class_lattice_html_ab7322e5340badb9df4d208554fd90a89"><div class="ttname"><a href="class_lattice.html#ab7322e5340badb9df4d208554fd90a89">Lattice::init</a></div><div class="ttdeci">void init(const Parameters_Lattice &amp;params, std::mt19937_64 *generator_ptr)</div><div class="ttdoc">Initializes the Lattice object using the provided Parameters_Lattice input parameter struct...</div><div class="ttdef"><b>Definition:</b> Lattice.cpp:15</div></div>
 <div class="ttc" id="class_lattice_html_a08adb2f412af409d3ec241e60e687c1a"><div class="ttname"><a href="class_lattice.html#a08adb2f412af409d3ec241e60e687c1a">Lattice::calculateDX</a></div><div class="ttdeci">int calculateDX(const int x, const int i) const</div><div class="ttdoc">Calculates a coordinate adjustment factor if the x-direction periodic boundary is crossed...</div><div class="ttdef"><b>Definition:</b> Lattice.cpp:33</div></div>
-<div class="ttc" id="class_lattice_html_accf3b995e0d0cb422907728a29b1b523"><div class="ttname"><a href="class_lattice.html#accf3b995e0d0cb422907728a29b1b523">Lattice::isXPeriodic</a></div><div class="ttdeci">bool isXPeriodic() const</div><div class="ttdoc">Checks whether the x-direction periodic boundaries are enabled or not. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:234</div></div>
-<div class="ttc" id="class_lattice_html_a4b43b67a36fcd3dfe62c9eeaffa561d2"><div class="ttname"><a href="class_lattice.html#a4b43b67a36fcd3dfe62c9eeaffa561d2">Lattice::getLength</a></div><div class="ttdeci">int getLength() const</div><div class="ttdoc">Gets the x-direction size of the lattice, the length. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:181</div></div>
-<div class="ttc" id="class_lattice_html_a46f9cec33419459b64ff0efdf47a38b9"><div class="ttname"><a href="class_lattice.html#a46f9cec33419459b64ff0efdf47a38b9">Lattice::getVolume</a></div><div class="ttdeci">double getVolume() const</div><div class="ttdoc">Gets the volume of the lattice in cm^-3. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:226</div></div>
-<div class="ttc" id="class_lattice_html_a4be17e9123f7737387991a9d1a8b87b3"><div class="ttname"><a href="class_lattice.html#a4be17e9123f7737387991a9d1a8b87b3">Lattice::getNumSites</a></div><div class="ttdeci">long int getNumSites() const</div><div class="ttdoc">Gets the number of sites contained in the lattice. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:185</div></div>
-<div class="ttc" id="class_lattice_html_ad7dd1b12a253e506aba5cedb57bf86ea"><div class="ttname"><a href="class_lattice.html#ad7dd1b12a253e506aba5cedb57bf86ea">Lattice::isZPeriodic</a></div><div class="ttdeci">bool isZPeriodic() const</div><div class="ttdoc">Checks whether the z-direction periodic boundaries are enabled or not. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:242</div></div>
-<div class="ttc" id="class_lattice_html_aa1f65735ecbd750ec04b6413b4d47316"><div class="ttname"><a href="class_lattice.html#aa1f65735ecbd750ec04b6413b4d47316">Lattice::outputLatticeOccupancy</a></div><div class="ttdeci">void outputLatticeOccupancy() const</div><div class="ttdoc">Prints to the command line which sites are occupied. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:246</div></div>
+<div class="ttc" id="class_lattice_html_accf3b995e0d0cb422907728a29b1b523"><div class="ttname"><a href="class_lattice.html#accf3b995e0d0cb422907728a29b1b523">Lattice::isXPeriodic</a></div><div class="ttdeci">bool isXPeriodic() const</div><div class="ttdoc">Checks whether the x-direction periodic boundaries are enabled or not. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:277</div></div>
+<div class="ttc" id="class_lattice_html_a4b43b67a36fcd3dfe62c9eeaffa561d2"><div class="ttname"><a href="class_lattice.html#a4b43b67a36fcd3dfe62c9eeaffa561d2">Lattice::getLength</a></div><div class="ttdeci">int getLength() const</div><div class="ttdoc">Gets the x-direction size of the lattice, the length. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:224</div></div>
+<div class="ttc" id="class_lattice_html_a46f9cec33419459b64ff0efdf47a38b9"><div class="ttname"><a href="class_lattice.html#a46f9cec33419459b64ff0efdf47a38b9">Lattice::getVolume</a></div><div class="ttdeci">double getVolume() const</div><div class="ttdoc">Gets the volume of the lattice in cm^-3. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:269</div></div>
+<div class="ttc" id="class_lattice_html_a4be17e9123f7737387991a9d1a8b87b3"><div class="ttname"><a href="class_lattice.html#a4be17e9123f7737387991a9d1a8b87b3">Lattice::getNumSites</a></div><div class="ttdeci">long int getNumSites() const</div><div class="ttdoc">Gets the number of sites contained in the lattice. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:228</div></div>
+<div class="ttc" id="class_lattice_html_ad7dd1b12a253e506aba5cedb57bf86ea"><div class="ttname"><a href="class_lattice.html#ad7dd1b12a253e506aba5cedb57bf86ea">Lattice::isZPeriodic</a></div><div class="ttdeci">bool isZPeriodic() const</div><div class="ttdoc">Checks whether the z-direction periodic boundaries are enabled or not. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:285</div></div>
+<div class="ttc" id="class_lattice_html_aa1f65735ecbd750ec04b6413b4d47316"><div class="ttname"><a href="class_lattice.html#aa1f65735ecbd750ec04b6413b4d47316">Lattice::outputLatticeOccupancy</a></div><div class="ttdeci">void outputLatticeOccupancy() const</div><div class="ttdoc">Prints to the command line which sites are occupied. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:289</div></div>
 <div class="ttc" id="struct_parameters___lattice_html_a5f9628b968ba4206a7650c774827b1f0"><div class="ttname"><a href="struct_parameters___lattice.html#a5f9628b968ba4206a7650c774827b1f0">Parameters_Lattice::Unit_size</a></div><div class="ttdeci">double Unit_size</div><div class="ttdoc">Defines the desired lattice unit size, which is used to convert lattice units into real space units...</div><div class="ttdef"><b>Definition:</b> Lattice.h:32</div></div>
-<div class="ttc" id="class_lattice_html_aeb60d2b8bfb02d9da8bef463f0d41428"><div class="ttname"><a href="class_lattice.html#aeb60d2b8bfb02d9da8bef463f0d41428">Lattice::getWidth</a></div><div class="ttdeci">int getWidth() const</div><div class="ttdoc">Gets the y-direction size of the lattice, the width. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:222</div></div>
+<div class="ttc" id="class_lattice_html_aeb60d2b8bfb02d9da8bef463f0d41428"><div class="ttname"><a href="class_lattice.html#aeb60d2b8bfb02d9da8bef463f0d41428">Lattice::getWidth</a></div><div class="ttdeci">int getWidth() const</div><div class="ttdoc">Gets the y-direction size of the lattice, the width. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:265</div></div>
 <div class="ttc" id="struct_coords_html"><div class="ttname"><a href="struct_coords.html">Coords</a></div><div class="ttdoc">This simple struct contains Cartesian coordinates specified by integers x,y,z. </div><div class="ttdef"><b>Definition:</b> Utils.h:25</div></div>
-<div class="ttc" id="class_lattice_html_a9fbb3c8bc23999ff685b6837beb62606"><div class="ttname"><a href="class_lattice.html#a9fbb3c8bc23999ff685b6837beb62606">Lattice::generateRandomCoords</a></div><div class="ttdeci">Coords generateRandomCoords()</div><div class="ttdoc">Generates the coordinates for a randomly selected site in the lattice. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:151</div></div>
+<div class="ttc" id="class_lattice_html_a9fbb3c8bc23999ff685b6837beb62606"><div class="ttname"><a href="class_lattice.html#a9fbb3c8bc23999ff685b6837beb62606">Lattice::generateRandomCoords</a></div><div class="ttdeci">Coords generateRandomCoords()</div><div class="ttdoc">Generates the coordinates for a randomly selected site in the lattice. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:197</div></div>
 <div class="ttc" id="struct_parameters___lattice_html_a1b59e1a307ad945fb86f44b68354f605"><div class="ttname"><a href="struct_parameters___lattice.html#a1b59e1a307ad945fb86f44b68354f605">Parameters_Lattice::Height</a></div><div class="ttdeci">int Height</div><div class="ttdoc">Defines the desired z-direction size of the lattice. </div><div class="ttdef"><b>Definition:</b> Lattice.h:30</div></div>
 <div class="ttc" id="struct_parameters___lattice_html_a40f8633b47d204f471d041a0d8216e5b"><div class="ttname"><a href="struct_parameters___lattice.html#a40f8633b47d204f471d041a0d8216e5b">Parameters_Lattice::Width</a></div><div class="ttdeci">int Width</div><div class="ttdoc">Defines the desired y-direction size of the lattice. </div><div class="ttdef"><b>Definition:</b> Lattice.h:28</div></div>
-<div class="ttc" id="class_lattice_html_a97a1b4f24cd40b81ed63aa2d7713b63b"><div class="ttname"><a href="class_lattice.html#a97a1b4f24cd40b81ed63aa2d7713b63b">Lattice::clearOccupancy</a></div><div class="ttdeci">void clearOccupancy(const Coords &amp;coords)</div><div class="ttdoc">Clears the occupancy of the site located at the specified coordinates. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:147</div></div>
+<div class="ttc" id="class_lattice_html_a97a1b4f24cd40b81ed63aa2d7713b63b"><div class="ttname"><a href="class_lattice.html#a97a1b4f24cd40b81ed63aa2d7713b63b">Lattice::clearOccupancy</a></div><div class="ttdeci">void clearOccupancy(const Coords &amp;coords)</div><div class="ttdoc">Clears the occupancy of the site located at the specified coordinates. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:193</div></div>
+<div class="ttc" id="class_lattice_html_abf954e8213010ab8aeac7a0b93a869bc"><div class="ttname"><a href="class_lattice.html#abf954e8213010ab8aeac7a0b93a869bc">Lattice::chooseRandomUnoccupiedNeighbor</a></div><div class="ttdeci">Coords chooseRandomUnoccupiedNeighbor(const Coords &amp;coords_i)</div><div class="ttdoc">Randomly selects a valid, unoccupied nearest neighbor site. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:147</div></div>
 <div class="ttc" id="class_lattice_html_ad0592298c4b92e9e84a768b95cd6d0f0"><div class="ttname"><a href="class_lattice.html#ad0592298c4b92e9e84a768b95cd6d0f0">Lattice::checkMoveValidity</a></div><div class="ttdeci">bool checkMoveValidity(const Coords &amp;coords_initial, const int i, const int j, const int k) const</div><div class="ttdoc">Checks to see if a generic move operation from the designated initial coordinates to a destination po...</div><div class="ttdef"><b>Definition:</b> Lattice.cpp:131</div></div>
 <div class="ttc" id="class_lattice_html"><div class="ttname"><a href="class_lattice.html">Lattice</a></div><div class="ttdoc">This class contains the properties of a three-dimensional lattice and the functions needed to interac...</div><div class="ttdef"><b>Definition:</b> Lattice.h:41</div></div>
-<div class="ttc" id="class_lattice_html_a46f7d12855d24e1bdd02814621b0a178"><div class="ttname"><a href="class_lattice.html#a46f7d12855d24e1bdd02814621b0a178">Lattice::getSiteIt</a></div><div class="ttdeci">std::vector&lt; Site * &gt;::iterator getSiteIt(const Coords &amp;coords)</div><div class="ttdoc">Gets the vector iterator for the site corresponding to the input coordinates. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:212</div></div>
+<div class="ttc" id="class_lattice_html_a46f7d12855d24e1bdd02814621b0a178"><div class="ttname"><a href="class_lattice.html#a46f7d12855d24e1bdd02814621b0a178">Lattice::getSiteIt</a></div><div class="ttdeci">std::vector&lt; Site * &gt;::iterator getSiteIt(const Coords &amp;coords)</div><div class="ttdoc">Gets the vector iterator for the site corresponding to the input coordinates. </div><div class="ttdef"><b>Definition:</b> Lattice.cpp:255</div></div>
 <div class="ttc" id="struct_parameters___lattice_html_a99c7d553111bb660032bb7ca6f592da6"><div class="ttname"><a href="struct_parameters___lattice.html#a99c7d553111bb660032bb7ca6f592da6">Parameters_Lattice::Length</a></div><div class="ttdeci">int Length</div><div class="ttdoc">Defines the desired x-direction size of the lattice. </div><div class="ttdef"><b>Definition:</b> Lattice.h:26</div></div>
 </div><!-- fragment --></div><!-- contents -->
 </div><!-- doc-content -->
diff --git a/docs/_simulation_8h_source.html b/docs/_simulation_8h_source.html
index d5ea36b..f3f916a 100644
--- a/docs/_simulation_8h_source.html
+++ b/docs/_simulation_8h_source.html
@@ -91,41 +91,42 @@
 <div class="title">Simulation.h</div>  </div>
 </div><!--header-->
 <div class="contents">
-<div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno">    1</span>&#160;<span class="comment">// Copyright (c) 2018 Michael C. Heiber</span></div><div class="line"><a name="l00002"></a><span class="lineno">    2</span>&#160;<span class="comment">// This source file is part of the KMC_Lattice project, which is subject to the MIT License.</span></div><div class="line"><a name="l00003"></a><span class="lineno">    3</span>&#160;<span class="comment">// For more information, see the LICENSE file that accompanies this software.</span></div><div class="line"><a name="l00004"></a><span class="lineno">    4</span>&#160;<span class="comment">// The KMC_Lattice project can be found on Github at https://github.com/MikeHeiber/KMC_Lattice</span></div><div class="line"><a name="l00005"></a><span class="lineno">    5</span>&#160;</div><div class="line"><a name="l00006"></a><span class="lineno">    6</span>&#160;<span class="preprocessor">#ifndef SIMULATION_H</span></div><div class="line"><a name="l00007"></a><span class="lineno">    7</span>&#160;<span class="preprocessor">#define SIMULATION_H</span></div><div class="line"><a name="l00008"></a><span class="lineno">    8</span>&#160;</div><div class="line"><a name="l00009"></a><span class="lineno">    9</span>&#160;<span class="preprocessor">#include &quot;Utils.h&quot;</span></div><div class="line"><a name="l00010"></a><span class="lineno">   10</span>&#160;<span class="preprocessor">#include &quot;Lattice.h&quot;</span></div><div class="line"><a name="l00011"></a><span class="lineno">   11</span>&#160;<span class="preprocessor">#include &quot;Object.h&quot;</span></div><div class="line"><a name="l00012"></a><span class="lineno">   12</span>&#160;<span class="preprocessor">#include &quot;Event.h&quot;</span></div><div class="line"><a name="l00013"></a><span class="lineno">   13</span>&#160;<span class="preprocessor">#include &lt;list&gt;</span></div><div class="line"><a name="l00014"></a><span class="lineno">   14</span>&#160;<span class="preprocessor">#include &lt;vector&gt;</span></div><div class="line"><a name="l00015"></a><span class="lineno">   15</span>&#160;<span class="preprocessor">#include &lt;random&gt;</span></div><div class="line"><a name="l00016"></a><span class="lineno">   16</span>&#160;<span class="preprocessor">#include &lt;iostream&gt;</span></div><div class="line"><a name="l00017"></a><span class="lineno">   17</span>&#160;<span class="preprocessor">#include &lt;fstream&gt;</span></div><div class="line"><a name="l00018"></a><span class="lineno">   18</span>&#160;<span class="preprocessor">#include &lt;sstream&gt;</span></div><div class="line"><a name="l00019"></a><span class="lineno">   19</span>&#160;<span class="preprocessor">#include &lt;ctime&gt;</span></div><div class="line"><a name="l00020"></a><span class="lineno">   20</span>&#160;</div><div class="line"><a name="l00025"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html">   25</a></span>&#160;<span class="keyword">struct </span><a class="code" href="struct_parameters___simulation.html">Parameters_Simulation</a>{</div><div class="line"><a name="l00026"></a><span class="lineno">   26</span>&#160;</div><div class="line"><a name="l00028"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#afde5aaac6f3cd226249cb9646a4c8a4b">   28</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___simulation.html#afde5aaac6f3cd226249cb9646a4c8a4b">Enable_logging</a>; </div><div class="line"><a name="l00030"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#a5624782454dd99271ad94923f53866b4">   30</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___simulation.html#a5624782454dd99271ad94923f53866b4">Enable_periodic_x</a>;</div><div class="line"><a name="l00032"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#a1c3d79a4dcf194f884e8a3d346c2261a">   32</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___simulation.html#a1c3d79a4dcf194f884e8a3d346c2261a">Enable_periodic_y</a>;</div><div class="line"><a name="l00034"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#a0d318f1a9eb75fa909b4ae8266696be1">   34</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___simulation.html#a0d318f1a9eb75fa909b4ae8266696be1">Enable_periodic_z</a>;</div><div class="line"><a name="l00036"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#a038f418e1b2e4fec3fc6a8336f8b23de">   36</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___simulation.html#a038f418e1b2e4fec3fc6a8336f8b23de">Length</a>;</div><div class="line"><a name="l00038"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#aab42f7eb6b5ec1916475d9022ed5165f">   38</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___simulation.html#aab42f7eb6b5ec1916475d9022ed5165f">Width</a>;</div><div class="line"><a name="l00040"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#aa1ffb86ac22065dbbb58196db95b3199">   40</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___simulation.html#aa1ffb86ac22065dbbb58196db95b3199">Height</a>;</div><div class="line"><a name="l00042"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#ab5dda6868bc9359d97a614f027734349">   42</a></span>&#160;    <span class="keywordtype">double</span> <a class="code" href="struct_parameters___simulation.html#ab5dda6868bc9359d97a614f027734349">Unit_size</a>;</div><div class="line"><a name="l00044"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#aad5bdf64239620d1b214c49532dba743">   44</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___simulation.html#aad5bdf64239620d1b214c49532dba743">Temperature</a>;</div><div class="line"><a name="l00046"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#a38edd7e56d80c80258d0563f602d09ea">   46</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___simulation.html#a38edd7e56d80c80258d0563f602d09ea">Enable_FRM</a>;</div><div class="line"><a name="l00048"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#a41834e14865ffe273bfb5824193371b9">   48</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___simulation.html#a41834e14865ffe273bfb5824193371b9">Enable_selective_recalc</a>;</div><div class="line"><a name="l00050"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#af55371ca9e7027e799f5be46e40eacc1">   50</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___simulation.html#af55371ca9e7027e799f5be46e40eacc1">Recalc_cutoff</a>;</div><div class="line"><a name="l00052"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#adc993369a04d510926341a72e4e54aad">   52</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___simulation.html#adc993369a04d510926341a72e4e54aad">Enable_full_recalc</a>;</div><div class="line"><a name="l00054"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#aa491c1f8ca5045b4cc9c8bbfcb930024">   54</a></span>&#160;    std::ofstream* <a class="code" href="struct_parameters___simulation.html#aa491c1f8ca5045b4cc9c8bbfcb930024">Logfile</a>;</div><div class="line"><a name="l00055"></a><span class="lineno">   55</span>&#160;};</div><div class="line"><a name="l00056"></a><span class="lineno">   56</span>&#160;</div><div class="line"><a name="l00063"></a><span class="lineno"><a class="line" href="class_simulation.html">   63</a></span>&#160;<span class="keyword">class </span><a class="code" href="class_simulation.html">Simulation</a>{</div><div class="line"><a name="l00064"></a><span class="lineno">   64</span>&#160;    <span class="keyword">public</span>:</div><div class="line"><a name="l00066"></a><span class="lineno">   66</span>&#160;        <span class="keyword">virtual</span> <a class="code" href="class_simulation.html#a80fad3f57dfaf195a36f7bc49bc88279">~Simulation</a>();</div><div class="line"><a name="l00067"></a><span class="lineno">   67</span>&#160;</div><div class="line"><a name="l00070"></a><span class="lineno">   70</span>&#160;        <a class="code" href="class_simulation.html#a5b224cc5b36bcc8eb29689aff223de41">Simulation</a>();</div><div class="line"><a name="l00071"></a><span class="lineno">   71</span>&#160;</div><div class="line"><a name="l00077"></a><span class="lineno">   77</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#af88e5e0634b373ba28f1dd87670725a6">init</a>(<span class="keyword">const</span> <a class="code" href="struct_parameters___simulation.html">Parameters_Simulation</a>&amp; params, <span class="keyword">const</span> <span class="keywordtype">int</span> <span class="keywordtype">id</span>);</div><div class="line"><a name="l00078"></a><span class="lineno">   78</span>&#160;        </div><div class="line"><a name="l00083"></a><span class="lineno">   83</span>&#160;        <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="class_simulation.html#af69bb46977a3a0084214a194c888e16c">checkFinished</a>() <span class="keyword">const</span> = 0;</div><div class="line"><a name="l00084"></a><span class="lineno">   84</span>&#160;</div><div class="line"><a name="l00089"></a><span class="lineno">   89</span>&#160;        <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="class_simulation.html#a48e9e82f9dac1acec5d063a9f6f6115e">executeNextEvent</a>() = 0;</div><div class="line"><a name="l00090"></a><span class="lineno">   90</span>&#160;</div><div class="line"><a name="l00093"></a><span class="lineno">   93</span>&#160;        std::string <a class="code" href="class_simulation.html#a03d249f04c0921c938d68337dfc65f56">getErrorMessage</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00094"></a><span class="lineno">   94</span>&#160;</div><div class="line"><a name="l00097"></a><span class="lineno">   97</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_simulation.html#a7d88f18a1ba988d7e77b8be8de5b10d1">getN_events</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00098"></a><span class="lineno">   98</span>&#160;</div><div class="line"><a name="l00100"></a><span class="lineno">  100</span>&#160;        <span class="keywordtype">long</span> <span class="keywordtype">int</span> <a class="code" href="class_simulation.html#a52cb5564151421cbefaca56357738de7">getN_events_executed</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00101"></a><span class="lineno">  101</span>&#160;</div><div class="line"><a name="l00105"></a><span class="lineno">  105</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_simulation.html#aff40f268758bd9a0f390a649fc45c05e">getId</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00106"></a><span class="lineno">  106</span>&#160;</div><div class="line"><a name="l00108"></a><span class="lineno">  108</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_simulation.html#ac00bce7c792fb67a75395c46c03efe0a">getTemp</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00109"></a><span class="lineno">  109</span>&#160;</div><div class="line"><a name="l00111"></a><span class="lineno">  111</span>&#160;        <span class="keywordtype">double</span> <a class="code" href="class_simulation.html#a391ac262089c8bda8e76ce930b1db88b">getTime</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00112"></a><span class="lineno">  112</span>&#160;</div><div class="line"><a name="l00114"></a><span class="lineno">  114</span>&#160;        <span class="keywordtype">double</span> <a class="code" href="class_simulation.html#a623c3fbc431ab74c2d2b2374a3b5a3a7">getVolume</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00115"></a><span class="lineno">  115</span>&#160;</div><div class="line"><a name="l00120"></a><span class="lineno">  120</span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_simulation.html#ac7c8a49a4cc506b850891480e0aae512">isLoggingEnabled</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00121"></a><span class="lineno">  121</span>&#160;</div><div class="line"><a name="l00123"></a><span class="lineno">  123</span>&#160;        <span class="keywordtype">double</span> <a class="code" href="class_simulation.html#a938de951b2766c6fb2b00cf9714caffa">rand01</a>();</div><div class="line"><a name="l00124"></a><span class="lineno">  124</span>&#160;</div><div class="line"><a name="l00127"></a><span class="lineno">  127</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#a1a825b9da67da43104137662694655bd">setGeneratorSeed</a>(<span class="keyword">const</span> <span class="keywordtype">int</span> seed);</div><div class="line"><a name="l00128"></a><span class="lineno">  128</span>&#160;</div><div class="line"><a name="l00129"></a><span class="lineno">  129</span>&#160;    <span class="keyword">protected</span>:</div><div class="line"><a name="l00131"></a><span class="lineno"><a class="line" href="class_simulation.html#a4c1d9071749e0fd93e70380cafb28417">  131</a></span>&#160;        std::mt19937 <a class="code" href="class_simulation.html#a4c1d9071749e0fd93e70380cafb28417">generator</a>;</div><div class="line"><a name="l00133"></a><span class="lineno"><a class="line" href="class_simulation.html#a741321a0bbc89d51b969abda469e6f96">  133</a></span>&#160;        std::ofstream* <a class="code" href="class_simulation.html#a741321a0bbc89d51b969abda469e6f96">Logfile</a>;</div><div class="line"><a name="l00135"></a><span class="lineno"><a class="line" href="class_simulation.html#afb2cf4feeb4d8292eeba8f9ef393c6a4">  135</a></span>&#160;        <a class="code" href="class_lattice.html">Lattice</a> <a class="code" href="class_simulation.html#afb2cf4feeb4d8292eeba8f9ef393c6a4">lattice</a>;</div><div class="line"><a name="l00137"></a><span class="lineno"><a class="line" href="class_simulation.html#a7f4615a7898fb83d09be5e7fad92bb47">  137</a></span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_simulation.html#a7f4615a7898fb83d09be5e7fad92bb47">Error_found</a> = <span class="keyword">false</span>;</div><div class="line"><a name="l00139"></a><span class="lineno"><a class="line" href="class_simulation.html#a954f41f4332dabda0fecea5d72151988">  139</a></span>&#160;        std::string <a class="code" href="class_simulation.html#a954f41f4332dabda0fecea5d72151988">error_msg</a>;</div><div class="line"><a name="l00140"></a><span class="lineno">  140</span>&#160;</div><div class="line"><a name="l00141"></a><span class="lineno">  141</span>&#160;        <span class="comment">//------ Functions</span></div><div class="line"><a name="l00142"></a><span class="lineno">  142</span>&#160;</div><div class="line"><a name="l00146"></a><span class="lineno">  146</span>&#160;        std::list&lt;Event*&gt;::const_iterator <a class="code" href="class_simulation.html#a33a57b5640b0d33c816dc6e57604162e">addEvent</a>(<a class="code" href="class_event.html">Event</a>* event_ptr);</div><div class="line"><a name="l00147"></a><span class="lineno">  147</span>&#160;</div><div class="line"><a name="l00150"></a><span class="lineno">  150</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#a1e0f43c4e11eda5486054c250f4de08f">addObject</a>(<a class="code" href="class_object.html">Object</a>* object_ptr);</div><div class="line"><a name="l00151"></a><span class="lineno">  151</span>&#160;</div><div class="line"><a name="l00155"></a><span class="lineno">  155</span>&#160;        std::list&lt;Event*&gt;::const_iterator <a class="code" href="class_simulation.html#af8cf2e5c24531582599423df2d70dc5b">chooseNextEvent</a>();</div><div class="line"><a name="l00156"></a><span class="lineno">  156</span>&#160;</div><div class="line"><a name="l00161"></a><span class="lineno">  161</span>&#160;        std::vector&lt;Object*&gt; <a class="code" href="class_simulation.html#a662702acf2d446dbdef0e1c87bf21038">findRecalcObjects</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_start, <span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_dest) <span class="keyword">const</span>;</div><div class="line"><a name="l00162"></a><span class="lineno">  162</span>&#160;</div><div class="line"><a name="l00164"></a><span class="lineno">  164</span>&#160;        std::vector&lt;Event*&gt; <a class="code" href="class_simulation.html#aec6a6e1a80eb566685e4d257e6f872c5">getAllEventPtrs</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00165"></a><span class="lineno">  165</span>&#160;</div><div class="line"><a name="l00167"></a><span class="lineno">  167</span>&#160;        std::vector&lt;Object*&gt; <a class="code" href="class_simulation.html#a620684b9ac1fb07344c4c2237ed9f352">getAllObjectPtrs</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00168"></a><span class="lineno">  168</span>&#160;</div><div class="line"><a name="l00172"></a><span class="lineno">  172</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#a59666ceba048bec35557cb8b691d24d9">moveObject</a>(<a class="code" href="class_object.html">Object</a>* object_ptr,<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_dest);</div><div class="line"><a name="l00173"></a><span class="lineno">  173</span>&#160;</div><div class="line"><a name="l00179"></a><span class="lineno">  179</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#a3a4808231d4760f0ab30ea39b6a67e8c">removeEvent</a>(<a class="code" href="class_event.html">Event</a>* event_ptr);</div><div class="line"><a name="l00180"></a><span class="lineno">  180</span>&#160;</div><div class="line"><a name="l00187"></a><span class="lineno">  187</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#a39da17feb9b487c05c9a834def44972f">removeObject</a>(<a class="code" href="class_object.html">Object</a>* object_ptr);</div><div class="line"><a name="l00188"></a><span class="lineno">  188</span>&#160;</div><div class="line"><a name="l00191"></a><span class="lineno">  191</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#a0f06c75c9dd6be20a3911781b48fd467">setErrorMessage</a>(<span class="keyword">const</span> std::string&amp; input_msg);</div><div class="line"><a name="l00192"></a><span class="lineno">  192</span>&#160;</div><div class="line"><a name="l00197"></a><span class="lineno">  197</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#a43ca861e2514feb7f93bf18ea3b73385">setObjectEvent</a>(<span class="keyword">const</span> <a class="code" href="class_object.html">Object</a>* object_ptr,<a class="code" href="class_event.html">Event</a>* event_ptr);</div><div class="line"><a name="l00198"></a><span class="lineno">  198</span>&#160;</div><div class="line"><a name="l00201"></a><span class="lineno">  201</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#aae315f0881f0b385c566f96beb01d3f6">setTime</a>(<span class="keyword">const</span> <span class="keywordtype">double</span> input_time);</div><div class="line"><a name="l00202"></a><span class="lineno">  202</span>&#160;        </div><div class="line"><a name="l00203"></a><span class="lineno">  203</span>&#160;    <span class="keyword">private</span>:</div><div class="line"><a name="l00204"></a><span class="lineno">  204</span>&#160;        <span class="keywordtype">int</span> Id;</div><div class="line"><a name="l00205"></a><span class="lineno">  205</span>&#160;        <span class="comment">// General Parameters</span></div><div class="line"><a name="l00206"></a><span class="lineno">  206</span>&#160;        <span class="keywordtype">bool</span> Enable_logging;</div><div class="line"><a name="l00207"></a><span class="lineno">  207</span>&#160;        <span class="keywordtype">int</span> temperature; <span class="comment">// Kelvin</span></div><div class="line"><a name="l00208"></a><span class="lineno">  208</span>&#160;        <span class="comment">// KMC Algorithm Event Recalculation Method Parameters</span></div><div class="line"><a name="l00209"></a><span class="lineno">  209</span>&#160;        <span class="keywordtype">bool</span> Enable_FRM;</div><div class="line"><a name="l00210"></a><span class="lineno">  210</span>&#160;        <span class="keywordtype">bool</span> Enable_selective_recalc;</div><div class="line"><a name="l00211"></a><span class="lineno">  211</span>&#160;        <span class="keywordtype">int</span> Recalc_cutoff;</div><div class="line"><a name="l00212"></a><span class="lineno">  212</span>&#160;        <span class="keywordtype">bool</span> Enable_full_recalc;</div><div class="line"><a name="l00213"></a><span class="lineno">  213</span>&#160;        <span class="comment">// Data Structures</span></div><div class="line"><a name="l00214"></a><span class="lineno">  214</span>&#160;        std::list&lt;Object*&gt; object_ptrs;</div><div class="line"><a name="l00215"></a><span class="lineno">  215</span>&#160;        std::list&lt;Event*&gt; event_ptrs;</div><div class="line"><a name="l00216"></a><span class="lineno">  216</span>&#160;        <span class="comment">// Counters</span></div><div class="line"><a name="l00217"></a><span class="lineno">  217</span>&#160;        <span class="keywordtype">double</span> time_sim = 0;</div><div class="line"><a name="l00218"></a><span class="lineno">  218</span>&#160;        <span class="keywordtype">long</span> <span class="keywordtype">int</span> N_objects_created = 0;</div><div class="line"><a name="l00219"></a><span class="lineno">  219</span>&#160;        <span class="keywordtype">long</span> <span class="keywordtype">int</span> N_events_executed = 0;</div><div class="line"><a name="l00220"></a><span class="lineno">  220</span>&#160;        <span class="comment">// Functions</span></div><div class="line"><a name="l00221"></a><span class="lineno">  221</span>&#160;</div><div class="line"><a name="l00226"></a><span class="lineno">  226</span>&#160;        std::vector&lt;Object*&gt; findRecalcNeighbors(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords) <span class="keyword">const</span>;</div><div class="line"><a name="l00227"></a><span class="lineno">  227</span>&#160;};</div><div class="line"><a name="l00228"></a><span class="lineno">  228</span>&#160;</div><div class="line"><a name="l00229"></a><span class="lineno">  229</span>&#160;<span class="preprocessor">#endif // SIMULATION_H</span></div><div class="ttc" id="class_simulation_html_af69bb46977a3a0084214a194c888e16c"><div class="ttname"><a href="class_simulation.html#af69bb46977a3a0084214a194c888e16c">Simulation::checkFinished</a></div><div class="ttdeci">virtual bool checkFinished() const =0</div><div class="ttdoc">Checks whether or not the simulation has finished. </div></div>
-<div class="ttc" id="class_simulation_html_a3a4808231d4760f0ab30ea39b6a67e8c"><div class="ttname"><a href="class_simulation.html#a3a4808231d4760f0ab30ea39b6a67e8c">Simulation::removeEvent</a></div><div class="ttdeci">void removeEvent(Event *event_ptr)</div><div class="ttdoc">Removes an Event pointer from the event list. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:203</div></div>
+<div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno">    1</span>&#160;<span class="comment">// Copyright (c) 2018 Michael C. Heiber</span></div><div class="line"><a name="l00002"></a><span class="lineno">    2</span>&#160;<span class="comment">// This source file is part of the KMC_Lattice project, which is subject to the MIT License.</span></div><div class="line"><a name="l00003"></a><span class="lineno">    3</span>&#160;<span class="comment">// For more information, see the LICENSE file that accompanies this software.</span></div><div class="line"><a name="l00004"></a><span class="lineno">    4</span>&#160;<span class="comment">// The KMC_Lattice project can be found on Github at https://github.com/MikeHeiber/KMC_Lattice</span></div><div class="line"><a name="l00005"></a><span class="lineno">    5</span>&#160;</div><div class="line"><a name="l00006"></a><span class="lineno">    6</span>&#160;<span class="preprocessor">#ifndef SIMULATION_H</span></div><div class="line"><a name="l00007"></a><span class="lineno">    7</span>&#160;<span class="preprocessor">#define SIMULATION_H</span></div><div class="line"><a name="l00008"></a><span class="lineno">    8</span>&#160;</div><div class="line"><a name="l00009"></a><span class="lineno">    9</span>&#160;<span class="preprocessor">#include &quot;Utils.h&quot;</span></div><div class="line"><a name="l00010"></a><span class="lineno">   10</span>&#160;<span class="preprocessor">#include &quot;Lattice.h&quot;</span></div><div class="line"><a name="l00011"></a><span class="lineno">   11</span>&#160;<span class="preprocessor">#include &quot;Object.h&quot;</span></div><div class="line"><a name="l00012"></a><span class="lineno">   12</span>&#160;<span class="preprocessor">#include &quot;Event.h&quot;</span></div><div class="line"><a name="l00013"></a><span class="lineno">   13</span>&#160;<span class="preprocessor">#include &lt;list&gt;</span></div><div class="line"><a name="l00014"></a><span class="lineno">   14</span>&#160;<span class="preprocessor">#include &lt;vector&gt;</span></div><div class="line"><a name="l00015"></a><span class="lineno">   15</span>&#160;<span class="preprocessor">#include &lt;random&gt;</span></div><div class="line"><a name="l00016"></a><span class="lineno">   16</span>&#160;<span class="preprocessor">#include &lt;iostream&gt;</span></div><div class="line"><a name="l00017"></a><span class="lineno">   17</span>&#160;<span class="preprocessor">#include &lt;fstream&gt;</span></div><div class="line"><a name="l00018"></a><span class="lineno">   18</span>&#160;<span class="preprocessor">#include &lt;sstream&gt;</span></div><div class="line"><a name="l00019"></a><span class="lineno">   19</span>&#160;<span class="preprocessor">#include &lt;ctime&gt;</span></div><div class="line"><a name="l00020"></a><span class="lineno">   20</span>&#160;</div><div class="line"><a name="l00025"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html">   25</a></span>&#160;<span class="keyword">struct </span><a class="code" href="struct_parameters___simulation.html">Parameters_Simulation</a>{</div><div class="line"><a name="l00026"></a><span class="lineno">   26</span>&#160;</div><div class="line"><a name="l00028"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#afde5aaac6f3cd226249cb9646a4c8a4b">   28</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___simulation.html#afde5aaac6f3cd226249cb9646a4c8a4b">Enable_logging</a>; </div><div class="line"><a name="l00030"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#a5624782454dd99271ad94923f53866b4">   30</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___simulation.html#a5624782454dd99271ad94923f53866b4">Enable_periodic_x</a>;</div><div class="line"><a name="l00032"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#a1c3d79a4dcf194f884e8a3d346c2261a">   32</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___simulation.html#a1c3d79a4dcf194f884e8a3d346c2261a">Enable_periodic_y</a>;</div><div class="line"><a name="l00034"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#a0d318f1a9eb75fa909b4ae8266696be1">   34</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___simulation.html#a0d318f1a9eb75fa909b4ae8266696be1">Enable_periodic_z</a>;</div><div class="line"><a name="l00036"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#a038f418e1b2e4fec3fc6a8336f8b23de">   36</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___simulation.html#a038f418e1b2e4fec3fc6a8336f8b23de">Length</a>;</div><div class="line"><a name="l00038"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#aab42f7eb6b5ec1916475d9022ed5165f">   38</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___simulation.html#aab42f7eb6b5ec1916475d9022ed5165f">Width</a>;</div><div class="line"><a name="l00040"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#aa1ffb86ac22065dbbb58196db95b3199">   40</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___simulation.html#aa1ffb86ac22065dbbb58196db95b3199">Height</a>;</div><div class="line"><a name="l00042"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#ab5dda6868bc9359d97a614f027734349">   42</a></span>&#160;    <span class="keywordtype">double</span> <a class="code" href="struct_parameters___simulation.html#ab5dda6868bc9359d97a614f027734349">Unit_size</a>;</div><div class="line"><a name="l00044"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#aad5bdf64239620d1b214c49532dba743">   44</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___simulation.html#aad5bdf64239620d1b214c49532dba743">Temperature</a>;</div><div class="line"><a name="l00046"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#a38edd7e56d80c80258d0563f602d09ea">   46</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___simulation.html#a38edd7e56d80c80258d0563f602d09ea">Enable_FRM</a>;</div><div class="line"><a name="l00048"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#a41834e14865ffe273bfb5824193371b9">   48</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___simulation.html#a41834e14865ffe273bfb5824193371b9">Enable_selective_recalc</a>;</div><div class="line"><a name="l00050"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#af55371ca9e7027e799f5be46e40eacc1">   50</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_parameters___simulation.html#af55371ca9e7027e799f5be46e40eacc1">Recalc_cutoff</a>;</div><div class="line"><a name="l00052"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#adc993369a04d510926341a72e4e54aad">   52</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_parameters___simulation.html#adc993369a04d510926341a72e4e54aad">Enable_full_recalc</a>;</div><div class="line"><a name="l00054"></a><span class="lineno"><a class="line" href="struct_parameters___simulation.html#aa491c1f8ca5045b4cc9c8bbfcb930024">   54</a></span>&#160;    std::ofstream* <a class="code" href="struct_parameters___simulation.html#aa491c1f8ca5045b4cc9c8bbfcb930024">Logfile</a>;</div><div class="line"><a name="l00055"></a><span class="lineno">   55</span>&#160;};</div><div class="line"><a name="l00056"></a><span class="lineno">   56</span>&#160;</div><div class="line"><a name="l00063"></a><span class="lineno"><a class="line" href="class_simulation.html">   63</a></span>&#160;<span class="keyword">class </span><a class="code" href="class_simulation.html">Simulation</a>{</div><div class="line"><a name="l00064"></a><span class="lineno">   64</span>&#160;    <span class="keyword">public</span>:</div><div class="line"><a name="l00066"></a><span class="lineno">   66</span>&#160;        <span class="keyword">virtual</span> <a class="code" href="class_simulation.html#a80fad3f57dfaf195a36f7bc49bc88279">~Simulation</a>();</div><div class="line"><a name="l00067"></a><span class="lineno">   67</span>&#160;</div><div class="line"><a name="l00070"></a><span class="lineno">   70</span>&#160;        <a class="code" href="class_simulation.html#a5b224cc5b36bcc8eb29689aff223de41">Simulation</a>();</div><div class="line"><a name="l00071"></a><span class="lineno">   71</span>&#160;</div><div class="line"><a name="l00077"></a><span class="lineno">   77</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#af88e5e0634b373ba28f1dd87670725a6">init</a>(<span class="keyword">const</span> <a class="code" href="struct_parameters___simulation.html">Parameters_Simulation</a>&amp; params, <span class="keyword">const</span> <span class="keywordtype">int</span> <span class="keywordtype">id</span>);</div><div class="line"><a name="l00078"></a><span class="lineno">   78</span>&#160;        </div><div class="line"><a name="l00083"></a><span class="lineno">   83</span>&#160;        <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="class_simulation.html#af69bb46977a3a0084214a194c888e16c">checkFinished</a>() <span class="keyword">const</span> = 0;</div><div class="line"><a name="l00084"></a><span class="lineno">   84</span>&#160;</div><div class="line"><a name="l00089"></a><span class="lineno">   89</span>&#160;        <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="class_simulation.html#a48e9e82f9dac1acec5d063a9f6f6115e">executeNextEvent</a>() = 0;</div><div class="line"><a name="l00090"></a><span class="lineno">   90</span>&#160;</div><div class="line"><a name="l00093"></a><span class="lineno">   93</span>&#160;        std::string <a class="code" href="class_simulation.html#a03d249f04c0921c938d68337dfc65f56">getErrorMessage</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00094"></a><span class="lineno">   94</span>&#160;</div><div class="line"><a name="l00097"></a><span class="lineno">   97</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_simulation.html#a7d88f18a1ba988d7e77b8be8de5b10d1">getN_events</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00098"></a><span class="lineno">   98</span>&#160;</div><div class="line"><a name="l00100"></a><span class="lineno">  100</span>&#160;        <span class="keywordtype">long</span> <span class="keywordtype">int</span> <a class="code" href="class_simulation.html#a52cb5564151421cbefaca56357738de7">getN_events_executed</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00101"></a><span class="lineno">  101</span>&#160;</div><div class="line"><a name="l00103"></a><span class="lineno">  103</span>&#160;        <span class="keywordtype">long</span> <span class="keywordtype">int</span> <a class="code" href="class_simulation.html#ab07386326b1844df84464abe30927bf5">getN_objects_created</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00104"></a><span class="lineno">  104</span>&#160;</div><div class="line"><a name="l00108"></a><span class="lineno">  108</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_simulation.html#aff40f268758bd9a0f390a649fc45c05e">getId</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00109"></a><span class="lineno">  109</span>&#160;</div><div class="line"><a name="l00111"></a><span class="lineno">  111</span>&#160;        <span class="keywordtype">int</span> <a class="code" href="class_simulation.html#ac00bce7c792fb67a75395c46c03efe0a">getTemp</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00112"></a><span class="lineno">  112</span>&#160;</div><div class="line"><a name="l00114"></a><span class="lineno">  114</span>&#160;        <span class="keywordtype">double</span> <a class="code" href="class_simulation.html#a391ac262089c8bda8e76ce930b1db88b">getTime</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00115"></a><span class="lineno">  115</span>&#160;</div><div class="line"><a name="l00117"></a><span class="lineno">  117</span>&#160;        <span class="keywordtype">double</span> <a class="code" href="class_simulation.html#a623c3fbc431ab74c2d2b2374a3b5a3a7">getVolume</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00118"></a><span class="lineno">  118</span>&#160;</div><div class="line"><a name="l00123"></a><span class="lineno">  123</span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_simulation.html#ac7c8a49a4cc506b850891480e0aae512">isLoggingEnabled</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00124"></a><span class="lineno">  124</span>&#160;</div><div class="line"><a name="l00126"></a><span class="lineno">  126</span>&#160;        <span class="keywordtype">double</span> <a class="code" href="class_simulation.html#a938de951b2766c6fb2b00cf9714caffa">rand01</a>();</div><div class="line"><a name="l00127"></a><span class="lineno">  127</span>&#160;</div><div class="line"><a name="l00130"></a><span class="lineno">  130</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#a1a825b9da67da43104137662694655bd">setGeneratorSeed</a>(<span class="keyword">const</span> <span class="keywordtype">int</span> seed);</div><div class="line"><a name="l00131"></a><span class="lineno">  131</span>&#160;</div><div class="line"><a name="l00132"></a><span class="lineno">  132</span>&#160;    <span class="keyword">protected</span>:</div><div class="line"><a name="l00134"></a><span class="lineno"><a class="line" href="class_simulation.html#a269659fa336a5563e2ccfe2db1654ba9">  134</a></span>&#160;        std::mt19937_64 <a class="code" href="class_simulation.html#a269659fa336a5563e2ccfe2db1654ba9">generator</a>;</div><div class="line"><a name="l00136"></a><span class="lineno"><a class="line" href="class_simulation.html#a741321a0bbc89d51b969abda469e6f96">  136</a></span>&#160;        std::ofstream* <a class="code" href="class_simulation.html#a741321a0bbc89d51b969abda469e6f96">Logfile</a>;</div><div class="line"><a name="l00138"></a><span class="lineno"><a class="line" href="class_simulation.html#afb2cf4feeb4d8292eeba8f9ef393c6a4">  138</a></span>&#160;        <a class="code" href="class_lattice.html">Lattice</a> <a class="code" href="class_simulation.html#afb2cf4feeb4d8292eeba8f9ef393c6a4">lattice</a>;</div><div class="line"><a name="l00140"></a><span class="lineno"><a class="line" href="class_simulation.html#a7f4615a7898fb83d09be5e7fad92bb47">  140</a></span>&#160;        <span class="keywordtype">bool</span> <a class="code" href="class_simulation.html#a7f4615a7898fb83d09be5e7fad92bb47">Error_found</a> = <span class="keyword">false</span>;</div><div class="line"><a name="l00142"></a><span class="lineno"><a class="line" href="class_simulation.html#a954f41f4332dabda0fecea5d72151988">  142</a></span>&#160;        std::string <a class="code" href="class_simulation.html#a954f41f4332dabda0fecea5d72151988">error_msg</a>;</div><div class="line"><a name="l00143"></a><span class="lineno">  143</span>&#160;</div><div class="line"><a name="l00144"></a><span class="lineno">  144</span>&#160;        <span class="comment">//------ Functions</span></div><div class="line"><a name="l00145"></a><span class="lineno">  145</span>&#160;</div><div class="line"><a name="l00149"></a><span class="lineno">  149</span>&#160;        std::list&lt;Event*&gt;::const_iterator <a class="code" href="class_simulation.html#a33a57b5640b0d33c816dc6e57604162e">addEvent</a>(<a class="code" href="class_event.html">Event</a>* event_ptr);</div><div class="line"><a name="l00150"></a><span class="lineno">  150</span>&#160;</div><div class="line"><a name="l00153"></a><span class="lineno">  153</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#a1e0f43c4e11eda5486054c250f4de08f">addObject</a>(<a class="code" href="class_object.html">Object</a>* object_ptr);</div><div class="line"><a name="l00154"></a><span class="lineno">  154</span>&#160;</div><div class="line"><a name="l00158"></a><span class="lineno">  158</span>&#160;        std::list&lt;Event*&gt;::const_iterator <a class="code" href="class_simulation.html#af8cf2e5c24531582599423df2d70dc5b">chooseNextEvent</a>();</div><div class="line"><a name="l00159"></a><span class="lineno">  159</span>&#160;</div><div class="line"><a name="l00164"></a><span class="lineno">  164</span>&#160;        std::vector&lt;Object*&gt; <a class="code" href="class_simulation.html#a662702acf2d446dbdef0e1c87bf21038">findRecalcObjects</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_start, <span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_dest) <span class="keyword">const</span>;</div><div class="line"><a name="l00165"></a><span class="lineno">  165</span>&#160;</div><div class="line"><a name="l00167"></a><span class="lineno">  167</span>&#160;        std::vector&lt;Event*&gt; <a class="code" href="class_simulation.html#aec6a6e1a80eb566685e4d257e6f872c5">getAllEventPtrs</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00168"></a><span class="lineno">  168</span>&#160;</div><div class="line"><a name="l00170"></a><span class="lineno">  170</span>&#160;        std::vector&lt;Object*&gt; <a class="code" href="class_simulation.html#a620684b9ac1fb07344c4c2237ed9f352">getAllObjectPtrs</a>() <span class="keyword">const</span>;</div><div class="line"><a name="l00171"></a><span class="lineno">  171</span>&#160;</div><div class="line"><a name="l00175"></a><span class="lineno">  175</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#a59666ceba048bec35557cb8b691d24d9">moveObject</a>(<a class="code" href="class_object.html">Object</a>* object_ptr,<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords_dest);</div><div class="line"><a name="l00176"></a><span class="lineno">  176</span>&#160;</div><div class="line"><a name="l00182"></a><span class="lineno">  182</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#a3a4808231d4760f0ab30ea39b6a67e8c">removeEvent</a>(<a class="code" href="class_event.html">Event</a>* event_ptr);</div><div class="line"><a name="l00183"></a><span class="lineno">  183</span>&#160;</div><div class="line"><a name="l00190"></a><span class="lineno">  190</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#a39da17feb9b487c05c9a834def44972f">removeObject</a>(<a class="code" href="class_object.html">Object</a>* object_ptr);</div><div class="line"><a name="l00191"></a><span class="lineno">  191</span>&#160;</div><div class="line"><a name="l00194"></a><span class="lineno">  194</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#a0f06c75c9dd6be20a3911781b48fd467">setErrorMessage</a>(<span class="keyword">const</span> std::string&amp; input_msg);</div><div class="line"><a name="l00195"></a><span class="lineno">  195</span>&#160;</div><div class="line"><a name="l00200"></a><span class="lineno">  200</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#a43ca861e2514feb7f93bf18ea3b73385">setObjectEvent</a>(<span class="keyword">const</span> <a class="code" href="class_object.html">Object</a>* object_ptr,<a class="code" href="class_event.html">Event</a>* event_ptr);</div><div class="line"><a name="l00201"></a><span class="lineno">  201</span>&#160;</div><div class="line"><a name="l00204"></a><span class="lineno">  204</span>&#160;        <span class="keywordtype">void</span> <a class="code" href="class_simulation.html#aae315f0881f0b385c566f96beb01d3f6">setTime</a>(<span class="keyword">const</span> <span class="keywordtype">double</span> input_time);</div><div class="line"><a name="l00205"></a><span class="lineno">  205</span>&#160;        </div><div class="line"><a name="l00206"></a><span class="lineno">  206</span>&#160;    <span class="keyword">private</span>:</div><div class="line"><a name="l00207"></a><span class="lineno">  207</span>&#160;        <span class="keywordtype">int</span> Id;</div><div class="line"><a name="l00208"></a><span class="lineno">  208</span>&#160;        <span class="comment">// General Parameters</span></div><div class="line"><a name="l00209"></a><span class="lineno">  209</span>&#160;        <span class="keywordtype">bool</span> Enable_logging;</div><div class="line"><a name="l00210"></a><span class="lineno">  210</span>&#160;        <span class="keywordtype">int</span> temperature; <span class="comment">// Kelvin</span></div><div class="line"><a name="l00211"></a><span class="lineno">  211</span>&#160;        <span class="comment">// KMC Algorithm Event Recalculation Method Parameters</span></div><div class="line"><a name="l00212"></a><span class="lineno">  212</span>&#160;        <span class="keywordtype">bool</span> Enable_FRM;</div><div class="line"><a name="l00213"></a><span class="lineno">  213</span>&#160;        <span class="keywordtype">bool</span> Enable_selective_recalc;</div><div class="line"><a name="l00214"></a><span class="lineno">  214</span>&#160;        <span class="keywordtype">int</span> Recalc_cutoff;</div><div class="line"><a name="l00215"></a><span class="lineno">  215</span>&#160;        <span class="keywordtype">bool</span> Enable_full_recalc;</div><div class="line"><a name="l00216"></a><span class="lineno">  216</span>&#160;        <span class="comment">// Data Structures</span></div><div class="line"><a name="l00217"></a><span class="lineno">  217</span>&#160;        std::list&lt;Object*&gt; object_ptrs;</div><div class="line"><a name="l00218"></a><span class="lineno">  218</span>&#160;        std::list&lt;Event*&gt; event_ptrs;</div><div class="line"><a name="l00219"></a><span class="lineno">  219</span>&#160;        <span class="comment">// Counters</span></div><div class="line"><a name="l00220"></a><span class="lineno">  220</span>&#160;        <span class="keywordtype">double</span> time_sim = 0.0;</div><div class="line"><a name="l00221"></a><span class="lineno">  221</span>&#160;        <span class="keywordtype">long</span> <span class="keywordtype">int</span> N_objects_created = 0;</div><div class="line"><a name="l00222"></a><span class="lineno">  222</span>&#160;        <span class="keywordtype">long</span> <span class="keywordtype">int</span> N_events_executed = 0;</div><div class="line"><a name="l00223"></a><span class="lineno">  223</span>&#160;        <span class="comment">// Functions</span></div><div class="line"><a name="l00224"></a><span class="lineno">  224</span>&#160;</div><div class="line"><a name="l00229"></a><span class="lineno">  229</span>&#160;        std::vector&lt;Object*&gt; findRecalcNeighbors(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; coords) <span class="keyword">const</span>;</div><div class="line"><a name="l00230"></a><span class="lineno">  230</span>&#160;};</div><div class="line"><a name="l00231"></a><span class="lineno">  231</span>&#160;</div><div class="line"><a name="l00232"></a><span class="lineno">  232</span>&#160;<span class="preprocessor">#endif // SIMULATION_H</span></div><div class="ttc" id="class_simulation_html_af69bb46977a3a0084214a194c888e16c"><div class="ttname"><a href="class_simulation.html#af69bb46977a3a0084214a194c888e16c">Simulation::checkFinished</a></div><div class="ttdeci">virtual bool checkFinished() const =0</div><div class="ttdoc">Checks whether or not the simulation has finished. </div></div>
+<div class="ttc" id="class_simulation_html_a3a4808231d4760f0ab30ea39b6a67e8c"><div class="ttname"><a href="class_simulation.html#a3a4808231d4760f0ab30ea39b6a67e8c">Simulation::removeEvent</a></div><div class="ttdeci">void removeEvent(Event *event_ptr)</div><div class="ttdoc">Removes an Event pointer from the event list. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:191</div></div>
 <div class="ttc" id="struct_parameters___simulation_html_aad5bdf64239620d1b214c49532dba743"><div class="ttname"><a href="struct_parameters___simulation.html#aad5bdf64239620d1b214c49532dba743">Parameters_Simulation::Temperature</a></div><div class="ttdeci">int Temperature</div><div class="ttdoc">Defines the desired temperature of the simulation in Kelvin. </div><div class="ttdef"><b>Definition:</b> Simulation.h:44</div></div>
-<div class="ttc" id="class_simulation_html_a662702acf2d446dbdef0e1c87bf21038"><div class="ttname"><a href="class_simulation.html#a662702acf2d446dbdef0e1c87bf21038">Simulation::findRecalcObjects</a></div><div class="ttdeci">std::vector&lt; Object * &gt; findRecalcObjects(const Coords &amp;coords_start, const Coords &amp;coords_dest) const</div><div class="ttdoc">Constructs and returns a vector of pointers to all Object objects that are to have their events recal...</div><div class="ttdef"><b>Definition:</b> Simulation.cpp:79</div></div>
-<div class="ttc" id="class_simulation_html_ac00bce7c792fb67a75395c46c03efe0a"><div class="ttname"><a href="class_simulation.html#ac00bce7c792fb67a75395c46c03efe0a">Simulation::getTemp</a></div><div class="ttdeci">int getTemp() const</div><div class="ttdoc">Gets the value of the temperature parameter. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:166</div></div>
-<div class="ttc" id="class_simulation_html_a7f4615a7898fb83d09be5e7fad92bb47"><div class="ttname"><a href="class_simulation.html#a7f4615a7898fb83d09be5e7fad92bb47">Simulation::Error_found</a></div><div class="ttdeci">bool Error_found</div><div class="ttdoc">The Error_found flag indicates whether or not there has been an error during one of the simulation op...</div><div class="ttdef"><b>Definition:</b> Simulation.h:137</div></div>
+<div class="ttc" id="class_simulation_html_a662702acf2d446dbdef0e1c87bf21038"><div class="ttname"><a href="class_simulation.html#a662702acf2d446dbdef0e1c87bf21038">Simulation::findRecalcObjects</a></div><div class="ttdeci">std::vector&lt; Object * &gt; findRecalcObjects(const Coords &amp;coords_start, const Coords &amp;coords_dest) const</div><div class="ttdoc">Constructs and returns a vector of pointers to all Object objects that are to have their events recal...</div><div class="ttdef"><b>Definition:</b> Simulation.cpp:73</div></div>
+<div class="ttc" id="class_simulation_html_ac00bce7c792fb67a75395c46c03efe0a"><div class="ttname"><a href="class_simulation.html#ac00bce7c792fb67a75395c46c03efe0a">Simulation::getTemp</a></div><div class="ttdeci">int getTemp() const</div><div class="ttdoc">Gets the value of the temperature parameter. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:154</div></div>
+<div class="ttc" id="class_simulation_html_a7f4615a7898fb83d09be5e7fad92bb47"><div class="ttname"><a href="class_simulation.html#a7f4615a7898fb83d09be5e7fad92bb47">Simulation::Error_found</a></div><div class="ttdeci">bool Error_found</div><div class="ttdoc">The Error_found flag indicates whether or not there has been an error during one of the simulation op...</div><div class="ttdef"><b>Definition:</b> Simulation.h:140</div></div>
 <div class="ttc" id="class_event_html"><div class="ttname"><a href="class_event.html">Event</a></div><div class="ttdoc">This base class contains the basic properties of a KMC simulation event and the functions needed to i...</div><div class="ttdef"><b>Definition:</b> Event.h:24</div></div>
 <div class="ttc" id="struct_parameters___simulation_html_a38edd7e56d80c80258d0563f602d09ea"><div class="ttname"><a href="struct_parameters___simulation.html#a38edd7e56d80c80258d0563f602d09ea">Parameters_Simulation::Enable_FRM</a></div><div class="ttdeci">bool Enable_FRM</div><div class="ttdoc">Determines whether the first reaction method will be used or not. </div><div class="ttdef"><b>Definition:</b> Simulation.h:46</div></div>
-<div class="ttc" id="class_simulation_html_aff40f268758bd9a0f390a649fc45c05e"><div class="ttname"><a href="class_simulation.html#aff40f268758bd9a0f390a649fc45c05e">Simulation::getId</a></div><div class="ttdeci">int getId() const</div><div class="ttdoc">Gets the processor ID number for the processor that is running the simulation. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:148</div></div>
-<div class="ttc" id="class_simulation_html_a620684b9ac1fb07344c4c2237ed9f352"><div class="ttname"><a href="class_simulation.html#a620684b9ac1fb07344c4c2237ed9f352">Simulation::getAllObjectPtrs</a></div><div class="ttdeci">std::vector&lt; Object * &gt; getAllObjectPtrs() const</div><div class="ttdoc">Returns a vector of pointers to all Object objects in the simulation. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:135</div></div>
+<div class="ttc" id="class_simulation_html_aff40f268758bd9a0f390a649fc45c05e"><div class="ttname"><a href="class_simulation.html#aff40f268758bd9a0f390a649fc45c05e">Simulation::getId</a></div><div class="ttdeci">int getId() const</div><div class="ttdoc">Gets the processor ID number for the processor that is running the simulation. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:136</div></div>
+<div class="ttc" id="class_simulation_html_a620684b9ac1fb07344c4c2237ed9f352"><div class="ttname"><a href="class_simulation.html#a620684b9ac1fb07344c4c2237ed9f352">Simulation::getAllObjectPtrs</a></div><div class="ttdeci">std::vector&lt; Object * &gt; getAllObjectPtrs() const</div><div class="ttdoc">Returns a vector of pointers to all Object objects in the simulation. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:123</div></div>
+<div class="ttc" id="class_simulation_html_a269659fa336a5563e2ccfe2db1654ba9"><div class="ttname"><a href="class_simulation.html#a269659fa336a5563e2ccfe2db1654ba9">Simulation::generator</a></div><div class="ttdeci">std::mt19937_64 generator</div><div class="ttdoc">Mersenne Twister random number generator. </div><div class="ttdef"><b>Definition:</b> Simulation.h:134</div></div>
 <div class="ttc" id="struct_parameters___simulation_html_a5624782454dd99271ad94923f53866b4"><div class="ttname"><a href="struct_parameters___simulation.html#a5624782454dd99271ad94923f53866b4">Parameters_Simulation::Enable_periodic_x</a></div><div class="ttdeci">bool Enable_periodic_x</div><div class="ttdoc">Determines whether the x-direction periodic boundary conditions will be enabled or not in the Lattice...</div><div class="ttdef"><b>Definition:</b> Simulation.h:30</div></div>
-<div class="ttc" id="class_simulation_html_a4c1d9071749e0fd93e70380cafb28417"><div class="ttname"><a href="class_simulation.html#a4c1d9071749e0fd93e70380cafb28417">Simulation::generator</a></div><div class="ttdeci">std::mt19937 generator</div><div class="ttdoc">Mersenne Twister random number generator. </div><div class="ttdef"><b>Definition:</b> Simulation.h:131</div></div>
-<div class="ttc" id="class_simulation_html_a0f06c75c9dd6be20a3911781b48fd467"><div class="ttname"><a href="class_simulation.html#a0f06c75c9dd6be20a3911781b48fd467">Simulation::setErrorMessage</a></div><div class="ttdeci">void setErrorMessage(const std::string &amp;input_msg)</div><div class="ttdoc">Sets the error_msg member variable to the input string. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:241</div></div>
-<div class="ttc" id="class_simulation_html_a43ca861e2514feb7f93bf18ea3b73385"><div class="ttname"><a href="class_simulation.html#a43ca861e2514feb7f93bf18ea3b73385">Simulation::setObjectEvent</a></div><div class="ttdeci">void setObjectEvent(const Object *object_ptr, Event *event_ptr)</div><div class="ttdoc">Overwrites the Event pointer in the event list associated with the indicated Object to the input Even...</div><div class="ttdef"><b>Definition:</b> Simulation.cpp:245</div></div>
-<div class="ttc" id="class_simulation_html_aae315f0881f0b385c566f96beb01d3f6"><div class="ttname"><a href="class_simulation.html#aae315f0881f0b385c566f96beb01d3f6">Simulation::setTime</a></div><div class="ttdeci">void setTime(const double input_time)</div><div class="ttdoc">Updates the simulation time with the input time. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:253</div></div>
-<div class="ttc" id="class_simulation_html_a1a825b9da67da43104137662694655bd"><div class="ttname"><a href="class_simulation.html#a1a825b9da67da43104137662694655bd">Simulation::setGeneratorSeed</a></div><div class="ttdeci">void setGeneratorSeed(const int seed)</div><div class="ttdoc">Sets the random number generator seed. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:249</div></div>
+<div class="ttc" id="class_simulation_html_a0f06c75c9dd6be20a3911781b48fd467"><div class="ttname"><a href="class_simulation.html#a0f06c75c9dd6be20a3911781b48fd467">Simulation::setErrorMessage</a></div><div class="ttdeci">void setErrorMessage(const std::string &amp;input_msg)</div><div class="ttdoc">Sets the error_msg member variable to the input string. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:221</div></div>
+<div class="ttc" id="class_simulation_html_a43ca861e2514feb7f93bf18ea3b73385"><div class="ttname"><a href="class_simulation.html#a43ca861e2514feb7f93bf18ea3b73385">Simulation::setObjectEvent</a></div><div class="ttdeci">void setObjectEvent(const Object *object_ptr, Event *event_ptr)</div><div class="ttdoc">Overwrites the Event pointer in the event list associated with the indicated Object to the input Even...</div><div class="ttdef"><b>Definition:</b> Simulation.cpp:225</div></div>
+<div class="ttc" id="class_simulation_html_aae315f0881f0b385c566f96beb01d3f6"><div class="ttname"><a href="class_simulation.html#aae315f0881f0b385c566f96beb01d3f6">Simulation::setTime</a></div><div class="ttdeci">void setTime(const double input_time)</div><div class="ttdoc">Updates the simulation time with the input time. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:233</div></div>
+<div class="ttc" id="class_simulation_html_a1a825b9da67da43104137662694655bd"><div class="ttname"><a href="class_simulation.html#a1a825b9da67da43104137662694655bd">Simulation::setGeneratorSeed</a></div><div class="ttdeci">void setGeneratorSeed(const int seed)</div><div class="ttdoc">Sets the random number generator seed. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:229</div></div>
 <div class="ttc" id="struct_parameters___simulation_html"><div class="ttname"><a href="struct_parameters___simulation.html">Parameters_Simulation</a></div><div class="ttdoc">This struct contains all of the main input parameters needed by the Simulation class. </div><div class="ttdef"><b>Definition:</b> Simulation.h:25</div></div>
-<div class="ttc" id="class_simulation_html_a954f41f4332dabda0fecea5d72151988"><div class="ttname"><a href="class_simulation.html#a954f41f4332dabda0fecea5d72151988">Simulation::error_msg</a></div><div class="ttdeci">std::string error_msg</div><div class="ttdoc">The error_msg string holds a message with information about the error that has occurred or is empty o...</div><div class="ttdef"><b>Definition:</b> Simulation.h:139</div></div>
-<div class="ttc" id="class_simulation_html_ac7c8a49a4cc506b850891480e0aae512"><div class="ttname"><a href="class_simulation.html#ac7c8a49a4cc506b850891480e0aae512">Simulation::isLoggingEnabled</a></div><div class="ttdeci">bool isLoggingEnabled() const</div><div class="ttdoc">Checks whether or not logging is enabled. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:178</div></div>
-<div class="ttc" id="class_simulation_html_a52cb5564151421cbefaca56357738de7"><div class="ttname"><a href="class_simulation.html#a52cb5564151421cbefaca56357738de7">Simulation::getN_events_executed</a></div><div class="ttdeci">long int getN_events_executed() const</div><div class="ttdoc">Gets the number of events that have been executed in the simulation. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:162</div></div>
+<div class="ttc" id="class_simulation_html_a954f41f4332dabda0fecea5d72151988"><div class="ttname"><a href="class_simulation.html#a954f41f4332dabda0fecea5d72151988">Simulation::error_msg</a></div><div class="ttdeci">std::string error_msg</div><div class="ttdoc">The error_msg string holds a message with information about the error that has occurred or is empty o...</div><div class="ttdef"><b>Definition:</b> Simulation.h:142</div></div>
+<div class="ttc" id="class_simulation_html_ac7c8a49a4cc506b850891480e0aae512"><div class="ttname"><a href="class_simulation.html#ac7c8a49a4cc506b850891480e0aae512">Simulation::isLoggingEnabled</a></div><div class="ttdeci">bool isLoggingEnabled() const</div><div class="ttdoc">Checks whether or not logging is enabled. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:166</div></div>
+<div class="ttc" id="class_simulation_html_a52cb5564151421cbefaca56357738de7"><div class="ttname"><a href="class_simulation.html#a52cb5564151421cbefaca56357738de7">Simulation::getN_events_executed</a></div><div class="ttdeci">long int getN_events_executed() const</div><div class="ttdoc">Gets the number of events that have been executed in the simulation. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:146</div></div>
 <div class="ttc" id="struct_parameters___simulation_html_a41834e14865ffe273bfb5824193371b9"><div class="ttname"><a href="struct_parameters___simulation.html#a41834e14865ffe273bfb5824193371b9">Parameters_Simulation::Enable_selective_recalc</a></div><div class="ttdeci">bool Enable_selective_recalc</div><div class="ttdoc">Determines whether the selective recalculation method will be used or not. </div><div class="ttdef"><b>Definition:</b> Simulation.h:48</div></div>
+<div class="ttc" id="class_simulation_html_ab07386326b1844df84464abe30927bf5"><div class="ttname"><a href="class_simulation.html#ab07386326b1844df84464abe30927bf5">Simulation::getN_objects_created</a></div><div class="ttdeci">long int getN_objects_created() const</div><div class="ttdoc">Gets the number of objects that have been created in the simulation. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:150</div></div>
 <div class="ttc" id="class_simulation_html_a80fad3f57dfaf195a36f7bc49bc88279"><div class="ttname"><a href="class_simulation.html#a80fad3f57dfaf195a36f7bc49bc88279">Simulation::~Simulation</a></div><div class="ttdeci">virtual ~Simulation()</div><div class="ttdoc">Default virtual destructor needed by the base class. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:15</div></div>
-<div class="ttc" id="class_simulation_html_a623c3fbc431ab74c2d2b2374a3b5a3a7"><div class="ttname"><a href="class_simulation.html#a623c3fbc431ab74c2d2b2374a3b5a3a7">Simulation::getVolume</a></div><div class="ttdeci">double getVolume() const</div><div class="ttdoc">Get the simulation box volume in cm^-3. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:174</div></div>
-<div class="ttc" id="class_simulation_html_aec6a6e1a80eb566685e4d257e6f872c5"><div class="ttname"><a href="class_simulation.html#aec6a6e1a80eb566685e4d257e6f872c5">Simulation::getAllEventPtrs</a></div><div class="ttdeci">std::vector&lt; Event * &gt; getAllEventPtrs() const</div><div class="ttdoc">Returns a vector of pointers to all Event objects in the simulation. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:126</div></div>
-<div class="ttc" id="class_simulation_html_a938de951b2766c6fb2b00cf9714caffa"><div class="ttname"><a href="class_simulation.html#a938de951b2766c6fb2b00cf9714caffa">Simulation::rand01</a></div><div class="ttdeci">double rand01()</div><div class="ttdoc">Generates a uniform random number from 0 to 1, not including 0. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:199</div></div>
-<div class="ttc" id="class_simulation_html_a391ac262089c8bda8e76ce930b1db88b"><div class="ttname"><a href="class_simulation.html#a391ac262089c8bda8e76ce930b1db88b">Simulation::getTime</a></div><div class="ttdeci">double getTime() const</div><div class="ttdoc">Get the current simulation time in units of seconds. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:170</div></div>
+<div class="ttc" id="class_simulation_html_a623c3fbc431ab74c2d2b2374a3b5a3a7"><div class="ttname"><a href="class_simulation.html#a623c3fbc431ab74c2d2b2374a3b5a3a7">Simulation::getVolume</a></div><div class="ttdeci">double getVolume() const</div><div class="ttdoc">Get the simulation box volume in cm^-3. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:162</div></div>
+<div class="ttc" id="class_simulation_html_aec6a6e1a80eb566685e4d257e6f872c5"><div class="ttname"><a href="class_simulation.html#aec6a6e1a80eb566685e4d257e6f872c5">Simulation::getAllEventPtrs</a></div><div class="ttdeci">std::vector&lt; Event * &gt; getAllEventPtrs() const</div><div class="ttdoc">Returns a vector of pointers to all Event objects in the simulation. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:114</div></div>
+<div class="ttc" id="class_simulation_html_a938de951b2766c6fb2b00cf9714caffa"><div class="ttname"><a href="class_simulation.html#a938de951b2766c6fb2b00cf9714caffa">Simulation::rand01</a></div><div class="ttdeci">double rand01()</div><div class="ttdoc">Generates a uniform random number from 0 to 1, not including 0. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:187</div></div>
+<div class="ttc" id="class_simulation_html_a391ac262089c8bda8e76ce930b1db88b"><div class="ttname"><a href="class_simulation.html#a391ac262089c8bda8e76ce930b1db88b">Simulation::getTime</a></div><div class="ttdeci">double getTime() const</div><div class="ttdoc">Get the current simulation time in units of seconds. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:158</div></div>
 <div class="ttc" id="class_simulation_html_a48e9e82f9dac1acec5d063a9f6f6115e"><div class="ttname"><a href="class_simulation.html#a48e9e82f9dac1acec5d063a9f6f6115e">Simulation::executeNextEvent</a></div><div class="ttdeci">virtual bool executeNextEvent()=0</div><div class="ttdoc">Executes the next event in the simulation. </div></div>
-<div class="ttc" id="class_simulation_html_a59666ceba048bec35557cb8b691d24d9"><div class="ttname"><a href="class_simulation.html#a59666ceba048bec35557cb8b691d24d9">Simulation::moveObject</a></div><div class="ttdeci">void moveObject(Object *object_ptr, const Coords &amp;coords_dest)</div><div class="ttdoc">Moves the designated object to the designated destination coordinates. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:182</div></div>
+<div class="ttc" id="class_simulation_html_a59666ceba048bec35557cb8b691d24d9"><div class="ttname"><a href="class_simulation.html#a59666ceba048bec35557cb8b691d24d9">Simulation::moveObject</a></div><div class="ttdeci">void moveObject(Object *object_ptr, const Coords &amp;coords_dest)</div><div class="ttdoc">Moves the designated object to the designated destination coordinates. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:170</div></div>
 <div class="ttc" id="struct_parameters___simulation_html_adc993369a04d510926341a72e4e54aad"><div class="ttname"><a href="struct_parameters___simulation.html#adc993369a04d510926341a72e4e54aad">Parameters_Simulation::Enable_full_recalc</a></div><div class="ttdeci">bool Enable_full_recalc</div><div class="ttdoc">Determines whether the full recalculation method will be used or not. </div><div class="ttdef"><b>Definition:</b> Simulation.h:52</div></div>
 <div class="ttc" id="class_simulation_html_a33a57b5640b0d33c816dc6e57604162e"><div class="ttname"><a href="class_simulation.html#a33a57b5640b0d33c816dc6e57604162e">Simulation::addEvent</a></div><div class="ttdeci">std::list&lt; Event * &gt;::const_iterator addEvent(Event *event_ptr)</div><div class="ttdoc">Adds a pointer to an Event object to the event list and returns the iterator to its position in the l...</div><div class="ttdef"><b>Definition:</b> Simulation.cpp:48</div></div>
 <div class="ttc" id="struct_parameters___simulation_html_af55371ca9e7027e799f5be46e40eacc1"><div class="ttname"><a href="struct_parameters___simulation.html#af55371ca9e7027e799f5be46e40eacc1">Parameters_Simulation::Recalc_cutoff</a></div><div class="ttdeci">int Recalc_cutoff</div><div class="ttdoc">Defines the desired event recalculation cutoff radius for the simulation in nm. </div><div class="ttdef"><b>Definition:</b> Simulation.h:50</div></div>
 <div class="ttc" id="class_simulation_html_af88e5e0634b373ba28f1dd87670725a6"><div class="ttname"><a href="class_simulation.html#af88e5e0634b373ba28f1dd87670725a6">Simulation::init</a></div><div class="ttdeci">void init(const Parameters_Simulation &amp;params, const int id)</div><div class="ttdoc">Initializes the Simulation object using the provided Parameters_Simulation struct containing the inpu...</div><div class="ttdef"><b>Definition:</b> Simulation.cpp:19</div></div>
 <div class="ttc" id="class_simulation_html_a5b224cc5b36bcc8eb29689aff223de41"><div class="ttname"><a href="class_simulation.html#a5b224cc5b36bcc8eb29689aff223de41">Simulation::Simulation</a></div><div class="ttdeci">Simulation()</div><div class="ttdoc">Default constructor that creates an empty Simulation object. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:11</div></div>
 <div class="ttc" id="struct_parameters___simulation_html_afde5aaac6f3cd226249cb9646a4c8a4b"><div class="ttname"><a href="struct_parameters___simulation.html#afde5aaac6f3cd226249cb9646a4c8a4b">Parameters_Simulation::Enable_logging</a></div><div class="ttdeci">bool Enable_logging</div><div class="ttdoc">Determines whether logging to a logfile during the simulation will be enabled or not. </div><div class="ttdef"><b>Definition:</b> Simulation.h:28</div></div>
-<div class="ttc" id="class_simulation_html_a03d249f04c0921c938d68337dfc65f56"><div class="ttname"><a href="class_simulation.html#a03d249f04c0921c938d68337dfc65f56">Simulation::getErrorMessage</a></div><div class="ttdeci">std::string getErrorMessage() const</div><div class="ttdoc">Gets the saved error message. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:144</div></div>
+<div class="ttc" id="class_simulation_html_a03d249f04c0921c938d68337dfc65f56"><div class="ttname"><a href="class_simulation.html#a03d249f04c0921c938d68337dfc65f56">Simulation::getErrorMessage</a></div><div class="ttdeci">std::string getErrorMessage() const</div><div class="ttdoc">Gets the saved error message. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:132</div></div>
 <div class="ttc" id="struct_parameters___simulation_html_a0d318f1a9eb75fa909b4ae8266696be1"><div class="ttname"><a href="struct_parameters___simulation.html#a0d318f1a9eb75fa909b4ae8266696be1">Parameters_Simulation::Enable_periodic_z</a></div><div class="ttdeci">bool Enable_periodic_z</div><div class="ttdoc">Determines whether the z-direction periodic boundary conditions will be enabled or not in the Lattice...</div><div class="ttdef"><b>Definition:</b> Simulation.h:34</div></div>
 <div class="ttc" id="class_simulation_html_af8cf2e5c24531582599423df2d70dc5b"><div class="ttname"><a href="class_simulation.html#af8cf2e5c24531582599423df2d70dc5b">Simulation::chooseNextEvent</a></div><div class="ttdeci">std::list&lt; Event * &gt;::const_iterator chooseNextEvent()</div><div class="ttdoc">Searches the event list and determines which event will be executed next. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:67</div></div>
 <div class="ttc" id="class_simulation_html"><div class="ttname"><a href="class_simulation.html">Simulation</a></div><div class="ttdoc">This abstract base class contains the basic properties of a KMC simulation and the functions needed t...</div><div class="ttdef"><b>Definition:</b> Simulation.h:63</div></div>
@@ -134,14 +135,14 @@
 <div class="ttc" id="struct_parameters___simulation_html_a1c3d79a4dcf194f884e8a3d346c2261a"><div class="ttname"><a href="struct_parameters___simulation.html#a1c3d79a4dcf194f884e8a3d346c2261a">Parameters_Simulation::Enable_periodic_y</a></div><div class="ttdeci">bool Enable_periodic_y</div><div class="ttdoc">Determines whether the y-direction periodic boundary conditions will be enabled or not in the Lattice...</div><div class="ttdef"><b>Definition:</b> Simulation.h:32</div></div>
 <div class="ttc" id="struct_coords_html"><div class="ttname"><a href="struct_coords.html">Coords</a></div><div class="ttdoc">This simple struct contains Cartesian coordinates specified by integers x,y,z. </div><div class="ttdef"><b>Definition:</b> Utils.h:25</div></div>
 <div class="ttc" id="class_object_html"><div class="ttname"><a href="class_object.html">Object</a></div><div class="ttdoc">This base class contains the basic properties of a KMC simulation object and the functions needed to ...</div><div class="ttdef"><b>Definition:</b> Object.h:22</div></div>
-<div class="ttc" id="class_simulation_html_a7d88f18a1ba988d7e77b8be8de5b10d1"><div class="ttname"><a href="class_simulation.html#a7d88f18a1ba988d7e77b8be8de5b10d1">Simulation::getN_events</a></div><div class="ttdeci">int getN_events() const</div><div class="ttdoc">Gets the number of events that are currently in the event list. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:152</div></div>
+<div class="ttc" id="class_simulation_html_a7d88f18a1ba988d7e77b8be8de5b10d1"><div class="ttname"><a href="class_simulation.html#a7d88f18a1ba988d7e77b8be8de5b10d1">Simulation::getN_events</a></div><div class="ttdeci">int getN_events() const</div><div class="ttdoc">Gets the number of events that are currently in the event list. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:140</div></div>
 <div class="ttc" id="struct_parameters___simulation_html_ab5dda6868bc9359d97a614f027734349"><div class="ttname"><a href="struct_parameters___simulation.html#ab5dda6868bc9359d97a614f027734349">Parameters_Simulation::Unit_size</a></div><div class="ttdeci">double Unit_size</div><div class="ttdoc">Defines the desired resolution of the Lattice in units of nm. </div><div class="ttdef"><b>Definition:</b> Simulation.h:42</div></div>
-<div class="ttc" id="class_simulation_html_a39da17feb9b487c05c9a834def44972f"><div class="ttname"><a href="class_simulation.html#a39da17feb9b487c05c9a834def44972f">Simulation::removeObject</a></div><div class="ttdeci">void removeObject(Object *object_ptr)</div><div class="ttdoc">Removes the Object pointer from the base simulation class. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:218</div></div>
+<div class="ttc" id="class_simulation_html_a39da17feb9b487c05c9a834def44972f"><div class="ttname"><a href="class_simulation.html#a39da17feb9b487c05c9a834def44972f">Simulation::removeObject</a></div><div class="ttdeci">void removeObject(Object *object_ptr)</div><div class="ttdoc">Removes the Object pointer from the base simulation class. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:202</div></div>
 <div class="ttc" id="class_lattice_html"><div class="ttname"><a href="class_lattice.html">Lattice</a></div><div class="ttdoc">This class contains the properties of a three-dimensional lattice and the functions needed to interac...</div><div class="ttdef"><b>Definition:</b> Lattice.h:41</div></div>
 <div class="ttc" id="class_simulation_html_a1e0f43c4e11eda5486054c250f4de08f"><div class="ttname"><a href="class_simulation.html#a1e0f43c4e11eda5486054c250f4de08f">Simulation::addObject</a></div><div class="ttdeci">void addObject(Object *object_ptr)</div><div class="ttdoc">Adds a pointer to an Object object to the object list. </div><div class="ttdef"><b>Definition:</b> Simulation.cpp:53</div></div>
 <div class="ttc" id="struct_parameters___simulation_html_a038f418e1b2e4fec3fc6a8336f8b23de"><div class="ttname"><a href="struct_parameters___simulation.html#a038f418e1b2e4fec3fc6a8336f8b23de">Parameters_Simulation::Length</a></div><div class="ttdeci">int Length</div><div class="ttdoc">Defines the desired x-direction size of the Lattice. </div><div class="ttdef"><b>Definition:</b> Simulation.h:36</div></div>
-<div class="ttc" id="class_simulation_html_afb2cf4feeb4d8292eeba8f9ef393c6a4"><div class="ttname"><a href="class_simulation.html#afb2cf4feeb4d8292eeba8f9ef393c6a4">Simulation::lattice</a></div><div class="ttdeci">Lattice lattice</div><div class="ttdoc">The Lattice object represents a three-dimensional lattice, its boundary conditions, and its occupancy. </div><div class="ttdef"><b>Definition:</b> Simulation.h:135</div></div>
-<div class="ttc" id="class_simulation_html_a741321a0bbc89d51b969abda469e6f96"><div class="ttname"><a href="class_simulation.html#a741321a0bbc89d51b969abda469e6f96">Simulation::Logfile</a></div><div class="ttdeci">std::ofstream * Logfile</div><div class="ttdoc">Pointer to an output file stream that is used to print log messages to a logfile when logging is enab...</div><div class="ttdef"><b>Definition:</b> Simulation.h:133</div></div>
+<div class="ttc" id="class_simulation_html_afb2cf4feeb4d8292eeba8f9ef393c6a4"><div class="ttname"><a href="class_simulation.html#afb2cf4feeb4d8292eeba8f9ef393c6a4">Simulation::lattice</a></div><div class="ttdeci">Lattice lattice</div><div class="ttdoc">The Lattice object represents a three-dimensional lattice, its boundary conditions, and its occupancy. </div><div class="ttdef"><b>Definition:</b> Simulation.h:138</div></div>
+<div class="ttc" id="class_simulation_html_a741321a0bbc89d51b969abda469e6f96"><div class="ttname"><a href="class_simulation.html#a741321a0bbc89d51b969abda469e6f96">Simulation::Logfile</a></div><div class="ttdeci">std::ofstream * Logfile</div><div class="ttdoc">Pointer to an output file stream that is used to print log messages to a logfile when logging is enab...</div><div class="ttdef"><b>Definition:</b> Simulation.h:136</div></div>
 <div class="ttc" id="struct_parameters___simulation_html_aa491c1f8ca5045b4cc9c8bbfcb930024"><div class="ttname"><a href="struct_parameters___simulation.html#aa491c1f8ca5045b4cc9c8bbfcb930024">Parameters_Simulation::Logfile</a></div><div class="ttdeci">std::ofstream * Logfile</div><div class="ttdoc">Defines the desired output file stream pointer to the logfile. </div><div class="ttdef"><b>Definition:</b> Simulation.h:54</div></div>
 </div><!-- fragment --></div><!-- contents -->
 </div><!-- doc-content -->
diff --git a/docs/_utils_8h_source.html b/docs/_utils_8h_source.html
index 1434dbb..6e51097 100644
--- a/docs/_utils_8h_source.html
+++ b/docs/_utils_8h_source.html
@@ -91,31 +91,33 @@
 <div class="title">Utils.h</div>  </div>
 </div><!--header-->
 <div class="contents">
-<div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno">    1</span>&#160;<span class="comment">// Copyright (c) 2018 Michael C. Heiber</span></div><div class="line"><a name="l00002"></a><span class="lineno">    2</span>&#160;<span class="comment">// This source file is part of the KMC_Lattice project, which is subject to the MIT License.</span></div><div class="line"><a name="l00003"></a><span class="lineno">    3</span>&#160;<span class="comment">// For more information, see the LICENSE file that accompanies this software.</span></div><div class="line"><a name="l00004"></a><span class="lineno">    4</span>&#160;<span class="comment">// The KMC_Lattice project can be found on Github at https://github.com/MikeHeiber/KMC_Lattice</span></div><div class="line"><a name="l00005"></a><span class="lineno">    5</span>&#160;</div><div class="line"><a name="l00006"></a><span class="lineno">    6</span>&#160;<span class="preprocessor">#ifndef UTILS_H</span></div><div class="line"><a name="l00007"></a><span class="lineno">    7</span>&#160;<span class="preprocessor">#define UTILS_H</span></div><div class="line"><a name="l00008"></a><span class="lineno">    8</span>&#160;</div><div class="line"><a name="l00009"></a><span class="lineno">    9</span>&#160;<span class="preprocessor">#include &lt;algorithm&gt;</span></div><div class="line"><a name="l00010"></a><span class="lineno">   10</span>&#160;<span class="preprocessor">#include &lt;cmath&gt;</span></div><div class="line"><a name="l00011"></a><span class="lineno">   11</span>&#160;<span class="preprocessor">#include &lt;functional&gt;</span></div><div class="line"><a name="l00012"></a><span class="lineno">   12</span>&#160;<span class="preprocessor">#include &lt;fstream&gt;</span></div><div class="line"><a name="l00013"></a><span class="lineno">   13</span>&#160;<span class="preprocessor">#include &lt;iostream&gt;</span></div><div class="line"><a name="l00014"></a><span class="lineno">   14</span>&#160;<span class="preprocessor">#include &lt;memory&gt;</span></div><div class="line"><a name="l00015"></a><span class="lineno">   15</span>&#160;<span class="preprocessor">#include &lt;mpi.h&gt;</span></div><div class="line"><a name="l00016"></a><span class="lineno">   16</span>&#160;<span class="preprocessor">#include &lt;random&gt;</span></div><div class="line"><a name="l00017"></a><span class="lineno">   17</span>&#160;<span class="preprocessor">#include &lt;set&gt;</span></div><div class="line"><a name="l00018"></a><span class="lineno">   18</span>&#160;<span class="preprocessor">#include &lt;string&gt;</span></div><div class="line"><a name="l00019"></a><span class="lineno">   19</span>&#160;<span class="preprocessor">#include &lt;vector&gt;</span></div><div class="line"><a name="l00020"></a><span class="lineno">   20</span>&#160;</div><div class="line"><a name="l00025"></a><span class="lineno"><a class="line" href="struct_coords.html">   25</a></span>&#160;<span class="keyword">struct </span><a class="code" href="struct_coords.html">Coords</a>{</div><div class="line"><a name="l00027"></a><span class="lineno"><a class="line" href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">   27</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">x</a>;</div><div class="line"><a name="l00029"></a><span class="lineno"><a class="line" href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">   29</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">y</a>;</div><div class="line"><a name="l00031"></a><span class="lineno"><a class="line" href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">   31</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">z</a>;</div><div class="line"><a name="l00032"></a><span class="lineno">   32</span>&#160;</div><div class="line"><a name="l00037"></a><span class="lineno"><a class="line" href="struct_coords.html#a88de3a6ee710766eb9c9444cee45a9f3">   37</a></span>&#160;    <span class="keywordtype">void</span> <a class="code" href="struct_coords.html#a88de3a6ee710766eb9c9444cee45a9f3">setXYZ</a>(<span class="keyword">const</span> <span class="keywordtype">int</span> xval,<span class="keyword">const</span> <span class="keywordtype">int</span> yval,<span class="keyword">const</span> <span class="keywordtype">int</span> zval){</div><div class="line"><a name="l00038"></a><span class="lineno">   38</span>&#160;        <a class="code" href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">x</a> = xval;</div><div class="line"><a name="l00039"></a><span class="lineno">   39</span>&#160;        <a class="code" href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">y</a> = yval;</div><div class="line"><a name="l00040"></a><span class="lineno">   40</span>&#160;        <a class="code" href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">z</a> = zval;</div><div class="line"><a name="l00041"></a><span class="lineno">   41</span>&#160;    }</div><div class="line"><a name="l00044"></a><span class="lineno"><a class="line" href="struct_coords.html#ad3347f6568814df1a2b98b3cd0b78632">   44</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_coords.html#ad3347f6568814df1a2b98b3cd0b78632">operator==</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; rhs)<span class="keyword"> const</span>{</div><div class="line"><a name="l00045"></a><span class="lineno">   45</span>&#160;        <span class="keywordflow">return</span> (<a class="code" href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">x</a> == rhs.<a class="code" href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">x</a> &amp;&amp; <a class="code" href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">y</a> == rhs.<a class="code" href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">y</a> &amp;&amp; <a class="code" href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">z</a> == rhs.<a class="code" href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">z</a>);</div><div class="line"><a name="l00046"></a><span class="lineno">   46</span>&#160;    }</div><div class="line"><a name="l00049"></a><span class="lineno"><a class="line" href="struct_coords.html#aaea2c566feec4e4bf56b27a34568be76">   49</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_coords.html#aaea2c566feec4e4bf56b27a34568be76">operator!=</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; rhs)<span class="keyword"> const </span>{</div><div class="line"><a name="l00050"></a><span class="lineno">   50</span>&#160;        <span class="keywordflow">return</span> (<a class="code" href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">x</a> != rhs.<a class="code" href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">x</a> || <a class="code" href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">y</a> != rhs.<a class="code" href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">y</a> || <a class="code" href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">z</a> != rhs.<a class="code" href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">z</a>);</div><div class="line"><a name="l00051"></a><span class="lineno">   51</span>&#160;    }</div><div class="line"><a name="l00052"></a><span class="lineno">   52</span>&#160;};</div><div class="line"><a name="l00053"></a><span class="lineno">   53</span>&#160;</div><div class="line"><a name="l00058"></a><span class="lineno">   58</span>&#160;<span class="keyword">namespace </span><a class="code" href="namespace_utils.html">Utils</a> {</div><div class="line"><a name="l00059"></a><span class="lineno">   59</span>&#160;</div><div class="line"><a name="l00060"></a><span class="lineno">   60</span>&#160;    <span class="comment">// Scientific Constants</span></div><div class="line"><a name="l00061"></a><span class="lineno">   61</span>&#160;    <span class="keyword">static</span> constexpr <span class="keywordtype">double</span> K_b = 8.61733035e-5;</div><div class="line"><a name="l00062"></a><span class="lineno">   62</span>&#160;    <span class="keyword">static</span> constexpr <span class="keywordtype">double</span> Elementary_charge = 1.602176621e-19; <span class="comment">// C</span></div><div class="line"><a name="l00063"></a><span class="lineno">   63</span>&#160;    <span class="keyword">static</span> constexpr <span class="keywordtype">double</span> Vacuum_permittivity = 8.854187818e-12; <span class="comment">// C/Vm</span></div><div class="line"><a name="l00064"></a><span class="lineno">   64</span>&#160;    <span class="keyword">static</span> constexpr <span class="keywordtype">double</span> Plank = 6.626070040e-34;</div><div class="line"><a name="l00065"></a><span class="lineno">   65</span>&#160;    <span class="keyword">static</span> constexpr <span class="keywordtype">double</span> Light_speed = 2.99792458e8;</div><div class="line"><a name="l00066"></a><span class="lineno">   66</span>&#160;    <span class="keyword">static</span> constexpr <span class="keywordtype">double</span> Pi = 3.14159265359;</div><div class="line"><a name="l00067"></a><span class="lineno">   67</span>&#160;    <span class="keyword">static</span> constexpr <span class="keywordtype">double</span> Coulomb_constant = 8.987551787e9; <span class="comment">// N m^2 C^-2</span></div><div class="line"><a name="l00068"></a><span class="lineno">   68</span>&#160;</div><div class="line"><a name="l00075"></a><span class="lineno">   75</span>&#160;    std::vector&lt;std::pair&lt;double,double&gt;&gt; <a class="code" href="namespace_utils.html#adcb2e98774b12bc12264034913547a2c">calculateProbabilityHist</a>(<span class="keyword">const</span> std::vector&lt;double&gt;&amp; data, <span class="keywordtype">int</span> num_bins);</div><div class="line"><a name="l00076"></a><span class="lineno">   76</span>&#160;</div><div class="line"><a name="l00083"></a><span class="lineno">   83</span>&#160;    std::vector&lt;std::pair&lt;double, double&gt;&gt; <a class="code" href="namespace_utils.html#adcb2e98774b12bc12264034913547a2c">calculateProbabilityHist</a>(<span class="keyword">const</span> std::vector&lt;double&gt;&amp; data, <span class="keywordtype">double</span> bin_size);</div><div class="line"><a name="l00084"></a><span class="lineno">   84</span>&#160;</div><div class="line"><a name="l00092"></a><span class="lineno">   92</span>&#160;    std::vector&lt;std::pair&lt;double, double&gt;&gt; <a class="code" href="namespace_utils.html#adcb2e98774b12bc12264034913547a2c">calculateProbabilityHist</a>(<span class="keyword">const</span> std::vector&lt;double&gt;&amp; data, <span class="keyword">const</span> <span class="keywordtype">double</span> bin_size, <span class="keyword">const</span> <span class="keywordtype">int</span> num_bins);</div><div class="line"><a name="l00093"></a><span class="lineno">   93</span>&#160;</div><div class="line"><a name="l00102"></a><span class="lineno">  102</span>&#160;    <span class="keywordtype">void</span> <a class="code" href="namespace_utils.html#af296d2aa8f889f67fe515fc641c5f5fe">createExponentialDOSVector</a>(std::vector&lt;double&gt;&amp; data, <span class="keyword">const</span> <span class="keywordtype">double</span> mode, <span class="keyword">const</span> <span class="keywordtype">double</span> urbach_energy, std::mt19937&amp; gen);</div><div class="line"><a name="l00103"></a><span class="lineno">  103</span>&#160;</div><div class="line"><a name="l00109"></a><span class="lineno">  109</span>&#160;    <span class="keywordtype">void</span> <a class="code" href="namespace_utils.html#a2ce45ade7d6d4f2995b595da3ebbaaec">createGaussianDOSVector</a>(std::vector&lt;double&gt;&amp; data, <span class="keyword">const</span> <span class="keywordtype">double</span> mean, <span class="keyword">const</span> <span class="keywordtype">double</span> stdev, std::mt19937&amp; gen);</div><div class="line"><a name="l00110"></a><span class="lineno">  110</span>&#160;</div><div class="line"><a name="l00116"></a><span class="lineno">  116</span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="namespace_utils.html#a98a0cc670327fc21e272a07cbf5025ec">importBooleanParam</a>(<span class="keyword">const</span> std::string&amp; input, <span class="keywordtype">bool</span>&amp; error_status);</div><div class="line"><a name="l00117"></a><span class="lineno">  117</span>&#160;</div><div class="line"><a name="l00122"></a><span class="lineno">  122</span>&#160;    <span class="keywordtype">double</span> <a class="code" href="namespace_utils.html#a49411c9d4c7a065dbcf237aa27a84023">integrateData</a>(<span class="keyword">const</span> std::vector&lt;std::pair&lt;double, double&gt;&gt;&amp; data);</div><div class="line"><a name="l00123"></a><span class="lineno">  123</span>&#160;</div><div class="line"><a name="l00129"></a><span class="lineno">  129</span>&#160;    <span class="keywordtype">double</span> <a class="code" href="namespace_utils.html#af68995497777ee14d812c65991a4046f">interpolateData</a>(<span class="keyword">const</span> std::vector&lt;std::pair&lt;double, double&gt;&gt;&amp; data, <span class="keyword">const</span> <span class="keywordtype">double</span> x_val);</div><div class="line"><a name="l00130"></a><span class="lineno">  130</span>&#160;</div><div class="line"><a name="l00137"></a><span class="lineno">  137</span>&#160;    std::vector&lt;double&gt; <a class="code" href="namespace_utils.html#a71eeb04d74f890da3d27128c37fcff78">MPI_calculateVectorAvg</a>(<span class="keyword">const</span> std::vector&lt;double&gt;&amp; input_vector);</div><div class="line"><a name="l00138"></a><span class="lineno">  138</span>&#160;</div><div class="line"><a name="l00145"></a><span class="lineno">  145</span>&#160;    std::vector&lt;double&gt; <a class="code" href="namespace_utils.html#a0a17d0ad939418dc745bcfd194ce2bc1">MPI_calculateVectorSum</a>(<span class="keyword">const</span> std::vector&lt;double&gt;&amp; input_vector);</div><div class="line"><a name="l00146"></a><span class="lineno">  146</span>&#160;</div><div class="line"><a name="l00153"></a><span class="lineno">  153</span>&#160;    std::vector&lt;int&gt; <a class="code" href="namespace_utils.html#a0a17d0ad939418dc745bcfd194ce2bc1">MPI_calculateVectorSum</a>(<span class="keyword">const</span> std::vector&lt;int&gt;&amp; input_vector);</div><div class="line"><a name="l00154"></a><span class="lineno">  154</span>&#160;</div><div class="line"><a name="l00161"></a><span class="lineno">  161</span>&#160;    std::vector&lt;double&gt; <a class="code" href="namespace_utils.html#aee439dad386e2477d34968311b166c85">MPI_gatherVectors</a>(<span class="keyword">const</span> std::vector&lt;double&gt;&amp; input_vector);</div><div class="line"><a name="l00162"></a><span class="lineno">  162</span>&#160;</div><div class="line"><a name="l00169"></a><span class="lineno">  169</span>&#160;    std::vector&lt;int&gt; <a class="code" href="namespace_utils.html#aee439dad386e2477d34968311b166c85">MPI_gatherVectors</a>(<span class="keyword">const</span> std::vector&lt;int&gt;&amp; input_vector);</div><div class="line"><a name="l00170"></a><span class="lineno">  170</span>&#160;</div><div class="line"><a name="l00174"></a><span class="lineno">  174</span>&#160;    std::string <a class="code" href="namespace_utils.html#af9ceee3373ffe317f07d177cf0dfe056">removeWhitespace</a>(<span class="keyword">const</span> std::string&amp; str);</div><div class="line"><a name="l00175"></a><span class="lineno">  175</span>&#160;</div><div class="line"><a name="l00176"></a><span class="lineno">  176</span>&#160;    <span class="comment">// Template functions</span></div><div class="line"><a name="l00177"></a><span class="lineno">  177</span>&#160;</div><div class="line"><a name="l00182"></a><span class="lineno">  182</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> T&gt;</div><div class="line"><a name="l00183"></a><span class="lineno"><a class="line" href="namespace_utils.html#aa76a204af4dd4c3eb151691825de2eb2">  183</a></span>&#160;    <span class="keywordtype">double</span> <a class="code" href="namespace_utils.html#aa76a204af4dd4c3eb151691825de2eb2">array_avg</a>(<span class="keyword">const</span> T data[], <span class="keyword">const</span> <span class="keywordtype">int</span> array_size) {</div><div class="line"><a name="l00184"></a><span class="lineno">  184</span>&#160;        <span class="keywordtype">double</span> sum = 0;</div><div class="line"><a name="l00185"></a><span class="lineno">  185</span>&#160;        <span class="keywordflow">for</span> (<span class="keywordtype">int</span> i = 0; i &lt; array_size; i++) {</div><div class="line"><a name="l00186"></a><span class="lineno">  186</span>&#160;            sum += data[i];</div><div class="line"><a name="l00187"></a><span class="lineno">  187</span>&#160;        }</div><div class="line"><a name="l00188"></a><span class="lineno">  188</span>&#160;        <span class="keywordflow">return</span> sum / array_size;</div><div class="line"><a name="l00189"></a><span class="lineno">  189</span>&#160;    }</div><div class="line"><a name="l00190"></a><span class="lineno">  190</span>&#160;</div><div class="line"><a name="l00195"></a><span class="lineno">  195</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> T&gt;</div><div class="line"><a name="l00196"></a><span class="lineno"><a class="line" href="namespace_utils.html#a25d09c704b5ae03f01cf76b6de10aa19">  196</a></span>&#160;    <span class="keywordtype">double</span> <a class="code" href="namespace_utils.html#a25d09c704b5ae03f01cf76b6de10aa19">array_stdev</a>(<span class="keyword">const</span> T data[], <span class="keyword">const</span> <span class="keywordtype">int</span> array_size) {</div><div class="line"><a name="l00197"></a><span class="lineno">  197</span>&#160;        <span class="keywordtype">double</span> sum = 0;</div><div class="line"><a name="l00198"></a><span class="lineno">  198</span>&#160;        <span class="keywordtype">double</span> avg = <a class="code" href="namespace_utils.html#aa76a204af4dd4c3eb151691825de2eb2">array_avg</a>(data, array_size);</div><div class="line"><a name="l00199"></a><span class="lineno">  199</span>&#160;        <span class="keywordflow">for</span> (<span class="keywordtype">int</span> i = 0; i &lt; array_size; i++) {</div><div class="line"><a name="l00200"></a><span class="lineno">  200</span>&#160;            sum += (data[i] - avg)*(data[i] - avg);</div><div class="line"><a name="l00201"></a><span class="lineno">  201</span>&#160;        }</div><div class="line"><a name="l00202"></a><span class="lineno">  202</span>&#160;        <span class="keywordflow">return</span> sqrt(sum / (array_size - 1));</div><div class="line"><a name="l00203"></a><span class="lineno">  203</span>&#160;    }</div><div class="line"><a name="l00204"></a><span class="lineno">  204</span>&#160;</div><div class="line"><a name="l00209"></a><span class="lineno">  209</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> base_type&gt;</div><div class="line"><a name="l00210"></a><span class="lineno"><a class="line" href="namespace_utils.html#affd19edaa58a3f8425e1f7b4c9233f8a">  210</a></span>&#160;    base_type <a class="code" href="namespace_utils.html#affd19edaa58a3f8425e1f7b4c9233f8a">intpow</a>(<span class="keyword">const</span> base_type base, <span class="keyword">const</span> <span class="keywordtype">int</span> exponent) {</div><div class="line"><a name="l00211"></a><span class="lineno">  211</span>&#160;        base_type result;</div><div class="line"><a name="l00212"></a><span class="lineno">  212</span>&#160;        <span class="keywordflow">if</span> (exponent == 0) {</div><div class="line"><a name="l00213"></a><span class="lineno">  213</span>&#160;            result = 1;</div><div class="line"><a name="l00214"></a><span class="lineno">  214</span>&#160;            <span class="keywordflow">return</span> result;</div><div class="line"><a name="l00215"></a><span class="lineno">  215</span>&#160;        }</div><div class="line"><a name="l00216"></a><span class="lineno">  216</span>&#160;        result = base;</div><div class="line"><a name="l00217"></a><span class="lineno">  217</span>&#160;        <span class="keywordflow">for</span> (<span class="keywordtype">int</span> i = 1; i &lt; abs(exponent); i++) {</div><div class="line"><a name="l00218"></a><span class="lineno">  218</span>&#160;            result *= base;</div><div class="line"><a name="l00219"></a><span class="lineno">  219</span>&#160;        }</div><div class="line"><a name="l00220"></a><span class="lineno">  220</span>&#160;        <span class="keywordflow">if</span> (exponent &lt; 0) {</div><div class="line"><a name="l00221"></a><span class="lineno">  221</span>&#160;            result = 1.0 / result;</div><div class="line"><a name="l00222"></a><span class="lineno">  222</span>&#160;        }</div><div class="line"><a name="l00223"></a><span class="lineno">  223</span>&#160;        <span class="keywordflow">return</span> result;</div><div class="line"><a name="l00224"></a><span class="lineno">  224</span>&#160;    }</div><div class="line"><a name="l00225"></a><span class="lineno">  225</span>&#160;</div><div class="line"><a name="l00230"></a><span class="lineno">  230</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> T&gt;</div><div class="line"><a name="l00231"></a><span class="lineno"><a class="line" href="namespace_utils.html#ab76081fb0fa0e9e1633b1b2255db4164">  231</a></span>&#160;    <span class="keywordtype">void</span> <a class="code" href="namespace_utils.html#ab76081fb0fa0e9e1633b1b2255db4164">outputVectorToFile</a>(std::vector&lt;T&gt;&amp; vec, std::string filename) {</div><div class="line"><a name="l00232"></a><span class="lineno">  232</span>&#160;        std::ofstream outfile;</div><div class="line"><a name="l00233"></a><span class="lineno">  233</span>&#160;        outfile.open(filename);</div><div class="line"><a name="l00234"></a><span class="lineno">  234</span>&#160;        <span class="keywordflow">for</span> (<span class="keyword">auto</span> <span class="keyword">const</span> &amp;item : vec) {</div><div class="line"><a name="l00235"></a><span class="lineno">  235</span>&#160;            outfile &lt;&lt; item &lt;&lt; <span class="stringliteral">&quot;\n&quot;</span>;</div><div class="line"><a name="l00236"></a><span class="lineno">  236</span>&#160;        }</div><div class="line"><a name="l00237"></a><span class="lineno">  237</span>&#160;        outfile.close();</div><div class="line"><a name="l00238"></a><span class="lineno">  238</span>&#160;    }</div><div class="line"><a name="l00239"></a><span class="lineno">  239</span>&#160;</div><div class="line"><a name="l00244"></a><span class="lineno">  244</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> T&gt;</div><div class="line"><a name="l00245"></a><span class="lineno"><a class="line" href="namespace_utils.html#a652ab00e72bce852c2b9798ff3e1a60b">  245</a></span>&#160;    <span class="keywordtype">void</span> <a class="code" href="namespace_utils.html#ab76081fb0fa0e9e1633b1b2255db4164">outputVectorToFile</a>(std::vector&lt;std::pair&lt;T,T&gt;&gt;&amp; vec, std::string filename) {</div><div class="line"><a name="l00246"></a><span class="lineno">  246</span>&#160;        std::ofstream outfile;</div><div class="line"><a name="l00247"></a><span class="lineno">  247</span>&#160;        outfile.open(filename);</div><div class="line"><a name="l00248"></a><span class="lineno">  248</span>&#160;        <span class="keywordflow">for</span> (<span class="keyword">auto</span> <span class="keyword">const</span> &amp;item : vec) {</div><div class="line"><a name="l00249"></a><span class="lineno">  249</span>&#160;            outfile &lt;&lt; item.first &lt;&lt; <span class="stringliteral">&quot;,&quot;</span> &lt;&lt; item.second &lt;&lt; <span class="stringliteral">&quot;\n&quot;</span>;</div><div class="line"><a name="l00250"></a><span class="lineno">  250</span>&#160;        }</div><div class="line"><a name="l00251"></a><span class="lineno">  251</span>&#160;        outfile.close();</div><div class="line"><a name="l00252"></a><span class="lineno">  252</span>&#160;    }</div><div class="line"><a name="l00253"></a><span class="lineno">  253</span>&#160;</div><div class="line"><a name="l00257"></a><span class="lineno">  257</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> T&gt;</div><div class="line"><a name="l00258"></a><span class="lineno"><a class="line" href="namespace_utils.html#a5f64d00eec0b50ac5bd119652c99d01b">  258</a></span>&#160;    <span class="keywordtype">void</span> <a class="code" href="namespace_utils.html#a5f64d00eec0b50ac5bd119652c99d01b">removeDuplicates</a>(std::vector&lt;T&gt; &amp;vec) {</div><div class="line"><a name="l00259"></a><span class="lineno">  259</span>&#160;        <span class="keywordflow">if</span> ((<span class="keywordtype">int</span>)vec.size() &gt; 2) {</div><div class="line"><a name="l00260"></a><span class="lineno">  260</span>&#160;            <span class="keywordflow">for</span> (<span class="keyword">auto</span> it1 = vec.begin(); it1 != vec.end() - 2; ++it1) {</div><div class="line"><a name="l00261"></a><span class="lineno">  261</span>&#160;                <span class="keywordflow">for</span> (<span class="keyword">auto</span> it2 = it1 + 2; it2 != vec.end(); ++it2) {</div><div class="line"><a name="l00262"></a><span class="lineno">  262</span>&#160;                    <span class="keywordflow">if</span> (*it2 == *it1) {</div><div class="line"><a name="l00263"></a><span class="lineno">  263</span>&#160;                        *it2 = *(it2 - 1);</div><div class="line"><a name="l00264"></a><span class="lineno">  264</span>&#160;                    }</div><div class="line"><a name="l00265"></a><span class="lineno">  265</span>&#160;                }</div><div class="line"><a name="l00266"></a><span class="lineno">  266</span>&#160;            }</div><div class="line"><a name="l00267"></a><span class="lineno">  267</span>&#160;        }</div><div class="line"><a name="l00268"></a><span class="lineno">  268</span>&#160;        <span class="keywordflow">if</span> ((<span class="keywordtype">int</span>)vec.size() &gt; 1) {</div><div class="line"><a name="l00269"></a><span class="lineno">  269</span>&#160;            <span class="keyword">auto</span> it3 = unique(vec.begin(), vec.end());</div><div class="line"><a name="l00270"></a><span class="lineno">  270</span>&#160;            vec.resize(distance(vec.begin(), it3));</div><div class="line"><a name="l00271"></a><span class="lineno">  271</span>&#160;        }</div><div class="line"><a name="l00272"></a><span class="lineno">  272</span>&#160;    }</div><div class="line"><a name="l00273"></a><span class="lineno">  273</span>&#160;</div><div class="line"><a name="l00277"></a><span class="lineno">  277</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> T, <span class="keyword">typename</span> A&gt;</div><div class="line"><a name="l00278"></a><span class="lineno"><a class="line" href="namespace_utils.html#acbc030ce708229ea393215fe13e6377b">  278</a></span>&#160;    <span class="keywordtype">double</span> <a class="code" href="namespace_utils.html#acbc030ce708229ea393215fe13e6377b">vector_avg</a>(<span class="keyword">const</span> std::vector&lt;T, A&gt;&amp; data) {</div><div class="line"><a name="l00279"></a><span class="lineno">  279</span>&#160;        <span class="keywordtype">double</span> sum = 0;</div><div class="line"><a name="l00280"></a><span class="lineno">  280</span>&#160;        <span class="keywordflow">for</span> (<span class="keyword">auto</span> <span class="keyword">const</span> &amp;item : data) {</div><div class="line"><a name="l00281"></a><span class="lineno">  281</span>&#160;            sum += item;</div><div class="line"><a name="l00282"></a><span class="lineno">  282</span>&#160;        }</div><div class="line"><a name="l00283"></a><span class="lineno">  283</span>&#160;        <span class="keywordflow">return</span> sum / data.size();</div><div class="line"><a name="l00284"></a><span class="lineno">  284</span>&#160;    }</div><div class="line"><a name="l00285"></a><span class="lineno">  285</span>&#160;</div><div class="line"><a name="l00289"></a><span class="lineno">  289</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> T, <span class="keyword">typename</span> A&gt;</div><div class="line"><a name="l00290"></a><span class="lineno"><a class="line" href="namespace_utils.html#a6bfa9b066d7c0967807d588024c15d4e">  290</a></span>&#160;    <span class="keywordtype">double</span> <a class="code" href="namespace_utils.html#a6bfa9b066d7c0967807d588024c15d4e">vector_stdev</a>(<span class="keyword">const</span> std::vector&lt;T, A&gt;&amp; data) {</div><div class="line"><a name="l00291"></a><span class="lineno">  291</span>&#160;        <span class="keywordtype">double</span> sum = 0;</div><div class="line"><a name="l00292"></a><span class="lineno">  292</span>&#160;        <span class="keywordtype">double</span> avg = <a class="code" href="namespace_utils.html#acbc030ce708229ea393215fe13e6377b">vector_avg</a>(data);</div><div class="line"><a name="l00293"></a><span class="lineno">  293</span>&#160;        <span class="keywordflow">for</span> (<span class="keyword">auto</span> <span class="keyword">const</span> &amp;item : data) {</div><div class="line"><a name="l00294"></a><span class="lineno">  294</span>&#160;            sum += (item - avg)*(item - avg);</div><div class="line"><a name="l00295"></a><span class="lineno">  295</span>&#160;        }</div><div class="line"><a name="l00296"></a><span class="lineno">  296</span>&#160;        <span class="keywordflow">return</span> sqrt(sum / (data.size() - 1));</div><div class="line"><a name="l00297"></a><span class="lineno">  297</span>&#160;    }</div><div class="line"><a name="l00298"></a><span class="lineno">  298</span>&#160;}</div><div class="line"><a name="l00299"></a><span class="lineno">  299</span>&#160;</div><div class="line"><a name="l00300"></a><span class="lineno">  300</span>&#160;<span class="preprocessor">#endif // UTILS_H</span></div><div class="ttc" id="namespace_utils_html_a6bfa9b066d7c0967807d588024c15d4e"><div class="ttname"><a href="namespace_utils.html#a6bfa9b066d7c0967807d588024c15d4e">Utils::vector_stdev</a></div><div class="ttdeci">double vector_stdev(const std::vector&lt; T, A &gt; &amp;data)</div><div class="ttdoc">This template function calculates and returns the standard deviation in double format when given a ve...</div><div class="ttdef"><b>Definition:</b> Utils.h:290</div></div>
+<div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno">    1</span>&#160;<span class="comment">// Copyright (c) 2018 Michael C. Heiber</span></div><div class="line"><a name="l00002"></a><span class="lineno">    2</span>&#160;<span class="comment">// This source file is part of the KMC_Lattice project, which is subject to the MIT License.</span></div><div class="line"><a name="l00003"></a><span class="lineno">    3</span>&#160;<span class="comment">// For more information, see the LICENSE file that accompanies this software.</span></div><div class="line"><a name="l00004"></a><span class="lineno">    4</span>&#160;<span class="comment">// The KMC_Lattice project can be found on Github at https://github.com/MikeHeiber/KMC_Lattice</span></div><div class="line"><a name="l00005"></a><span class="lineno">    5</span>&#160;</div><div class="line"><a name="l00006"></a><span class="lineno">    6</span>&#160;<span class="preprocessor">#ifndef UTILS_H</span></div><div class="line"><a name="l00007"></a><span class="lineno">    7</span>&#160;<span class="preprocessor">#define UTILS_H</span></div><div class="line"><a name="l00008"></a><span class="lineno">    8</span>&#160;</div><div class="line"><a name="l00009"></a><span class="lineno">    9</span>&#160;<span class="preprocessor">#include &lt;algorithm&gt;</span></div><div class="line"><a name="l00010"></a><span class="lineno">   10</span>&#160;<span class="preprocessor">#include &lt;cmath&gt;</span></div><div class="line"><a name="l00011"></a><span class="lineno">   11</span>&#160;<span class="preprocessor">#include &lt;functional&gt;</span></div><div class="line"><a name="l00012"></a><span class="lineno">   12</span>&#160;<span class="preprocessor">#include &lt;fstream&gt;</span></div><div class="line"><a name="l00013"></a><span class="lineno">   13</span>&#160;<span class="preprocessor">#include &lt;iostream&gt;</span></div><div class="line"><a name="l00014"></a><span class="lineno">   14</span>&#160;<span class="preprocessor">#include &lt;memory&gt;</span></div><div class="line"><a name="l00015"></a><span class="lineno">   15</span>&#160;<span class="preprocessor">#include &lt;mpi.h&gt;</span></div><div class="line"><a name="l00016"></a><span class="lineno">   16</span>&#160;<span class="preprocessor">#include &lt;random&gt;</span></div><div class="line"><a name="l00017"></a><span class="lineno">   17</span>&#160;<span class="preprocessor">#include &lt;set&gt;</span></div><div class="line"><a name="l00018"></a><span class="lineno">   18</span>&#160;<span class="preprocessor">#include &lt;string&gt;</span></div><div class="line"><a name="l00019"></a><span class="lineno">   19</span>&#160;<span class="preprocessor">#include &lt;vector&gt;</span></div><div class="line"><a name="l00020"></a><span class="lineno">   20</span>&#160;</div><div class="line"><a name="l00025"></a><span class="lineno"><a class="line" href="struct_coords.html">   25</a></span>&#160;<span class="keyword">struct </span><a class="code" href="struct_coords.html">Coords</a>{</div><div class="line"><a name="l00027"></a><span class="lineno"><a class="line" href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">   27</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">x</a>;</div><div class="line"><a name="l00029"></a><span class="lineno"><a class="line" href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">   29</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">y</a>;</div><div class="line"><a name="l00031"></a><span class="lineno"><a class="line" href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">   31</a></span>&#160;    <span class="keywordtype">int</span> <a class="code" href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">z</a>;</div><div class="line"><a name="l00032"></a><span class="lineno">   32</span>&#160;</div><div class="line"><a name="l00034"></a><span class="lineno"><a class="line" href="struct_coords.html#a5922d1783cefa759950faa50ac347191">   34</a></span>&#160;    <a class="code" href="struct_coords.html#a5922d1783cefa759950faa50ac347191">Coords</a>(){}</div><div class="line"><a name="l00035"></a><span class="lineno">   35</span>&#160;</div><div class="line"><a name="l00040"></a><span class="lineno"><a class="line" href="struct_coords.html#a246211bba85765d5d67953922070d11f">   40</a></span>&#160;    <a class="code" href="struct_coords.html#a246211bba85765d5d67953922070d11f">Coords</a>(<span class="keyword">const</span> <span class="keywordtype">int</span> xval, <span class="keyword">const</span> <span class="keywordtype">int</span> yval, <span class="keyword">const</span> <span class="keywordtype">int</span> zval) {</div><div class="line"><a name="l00041"></a><span class="lineno">   41</span>&#160;        <a class="code" href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">x</a> = xval;</div><div class="line"><a name="l00042"></a><span class="lineno">   42</span>&#160;        <a class="code" href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">y</a> = yval;</div><div class="line"><a name="l00043"></a><span class="lineno">   43</span>&#160;        <a class="code" href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">z</a> = zval;</div><div class="line"><a name="l00044"></a><span class="lineno">   44</span>&#160;    }</div><div class="line"><a name="l00045"></a><span class="lineno">   45</span>&#160;</div><div class="line"><a name="l00050"></a><span class="lineno"><a class="line" href="struct_coords.html#a88de3a6ee710766eb9c9444cee45a9f3">   50</a></span>&#160;    <span class="keywordtype">void</span> <a class="code" href="struct_coords.html#a88de3a6ee710766eb9c9444cee45a9f3">setXYZ</a>(<span class="keyword">const</span> <span class="keywordtype">int</span> xval,<span class="keyword">const</span> <span class="keywordtype">int</span> yval,<span class="keyword">const</span> <span class="keywordtype">int</span> zval){</div><div class="line"><a name="l00051"></a><span class="lineno">   51</span>&#160;        <a class="code" href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">x</a> = xval;</div><div class="line"><a name="l00052"></a><span class="lineno">   52</span>&#160;        <a class="code" href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">y</a> = yval;</div><div class="line"><a name="l00053"></a><span class="lineno">   53</span>&#160;        <a class="code" href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">z</a> = zval;</div><div class="line"><a name="l00054"></a><span class="lineno">   54</span>&#160;    }</div><div class="line"><a name="l00057"></a><span class="lineno"><a class="line" href="struct_coords.html#ad3347f6568814df1a2b98b3cd0b78632">   57</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_coords.html#ad3347f6568814df1a2b98b3cd0b78632">operator==</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; rhs)<span class="keyword"> const</span>{</div><div class="line"><a name="l00058"></a><span class="lineno">   58</span>&#160;        <span class="keywordflow">return</span> (<a class="code" href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">x</a> == rhs.<a class="code" href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">x</a> &amp;&amp; <a class="code" href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">y</a> == rhs.<a class="code" href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">y</a> &amp;&amp; <a class="code" href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">z</a> == rhs.<a class="code" href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">z</a>);</div><div class="line"><a name="l00059"></a><span class="lineno">   59</span>&#160;    }</div><div class="line"><a name="l00062"></a><span class="lineno"><a class="line" href="struct_coords.html#aaea2c566feec4e4bf56b27a34568be76">   62</a></span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="struct_coords.html#aaea2c566feec4e4bf56b27a34568be76">operator!=</a>(<span class="keyword">const</span> <a class="code" href="struct_coords.html">Coords</a>&amp; rhs)<span class="keyword"> const </span>{</div><div class="line"><a name="l00063"></a><span class="lineno">   63</span>&#160;        <span class="keywordflow">return</span> (<a class="code" href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">x</a> != rhs.<a class="code" href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">x</a> || <a class="code" href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">y</a> != rhs.<a class="code" href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">y</a> || <a class="code" href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">z</a> != rhs.<a class="code" href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">z</a>);</div><div class="line"><a name="l00064"></a><span class="lineno">   64</span>&#160;    }</div><div class="line"><a name="l00065"></a><span class="lineno">   65</span>&#160;};</div><div class="line"><a name="l00066"></a><span class="lineno">   66</span>&#160;</div><div class="line"><a name="l00071"></a><span class="lineno">   71</span>&#160;<span class="keyword">namespace </span><a class="code" href="namespace_utils.html">Utils</a> {</div><div class="line"><a name="l00072"></a><span class="lineno">   72</span>&#160;</div><div class="line"><a name="l00073"></a><span class="lineno">   73</span>&#160;    <span class="comment">// Scientific Constants</span></div><div class="line"><a name="l00074"></a><span class="lineno">   74</span>&#160;    <span class="keyword">static</span> constexpr <span class="keywordtype">double</span> K_b = 8.61733035e-5;</div><div class="line"><a name="l00075"></a><span class="lineno">   75</span>&#160;    <span class="keyword">static</span> constexpr <span class="keywordtype">double</span> Elementary_charge = 1.602176621e-19; <span class="comment">// C</span></div><div class="line"><a name="l00076"></a><span class="lineno">   76</span>&#160;    <span class="keyword">static</span> constexpr <span class="keywordtype">double</span> Vacuum_permittivity = 8.854187818e-12; <span class="comment">// C/Vm</span></div><div class="line"><a name="l00077"></a><span class="lineno">   77</span>&#160;    <span class="keyword">static</span> constexpr <span class="keywordtype">double</span> Plank = 6.626070040e-34;</div><div class="line"><a name="l00078"></a><span class="lineno">   78</span>&#160;    <span class="keyword">static</span> constexpr <span class="keywordtype">double</span> Light_speed = 2.99792458e8;</div><div class="line"><a name="l00079"></a><span class="lineno">   79</span>&#160;    <span class="keyword">static</span> constexpr <span class="keywordtype">double</span> Pi = 3.14159265359;</div><div class="line"><a name="l00080"></a><span class="lineno">   80</span>&#160;    <span class="keyword">static</span> constexpr <span class="keywordtype">double</span> Coulomb_constant = 8.987551787e9; <span class="comment">// N m^2 C^-2</span></div><div class="line"><a name="l00081"></a><span class="lineno">   81</span>&#160;</div><div class="line"><a name="l00088"></a><span class="lineno">   88</span>&#160;    std::vector&lt;std::pair&lt;double,double&gt;&gt; <a class="code" href="namespace_utils.html#adcb2e98774b12bc12264034913547a2c">calculateProbabilityHist</a>(<span class="keyword">const</span> std::vector&lt;double&gt;&amp; data, <span class="keywordtype">int</span> num_bins);</div><div class="line"><a name="l00089"></a><span class="lineno">   89</span>&#160;</div><div class="line"><a name="l00096"></a><span class="lineno">   96</span>&#160;    std::vector&lt;std::pair&lt;double, double&gt;&gt; <a class="code" href="namespace_utils.html#adcb2e98774b12bc12264034913547a2c">calculateProbabilityHist</a>(<span class="keyword">const</span> std::vector&lt;double&gt;&amp; data, <span class="keywordtype">double</span> bin_size);</div><div class="line"><a name="l00097"></a><span class="lineno">   97</span>&#160;</div><div class="line"><a name="l00105"></a><span class="lineno">  105</span>&#160;    std::vector&lt;std::pair&lt;double, double&gt;&gt; <a class="code" href="namespace_utils.html#adcb2e98774b12bc12264034913547a2c">calculateProbabilityHist</a>(<span class="keyword">const</span> std::vector&lt;double&gt;&amp; data, <span class="keyword">const</span> <span class="keywordtype">double</span> bin_size, <span class="keyword">const</span> <span class="keywordtype">int</span> num_bins);</div><div class="line"><a name="l00106"></a><span class="lineno">  106</span>&#160;</div><div class="line"><a name="l00115"></a><span class="lineno">  115</span>&#160;    <span class="keywordtype">void</span> <a class="code" href="namespace_utils.html#a62ed21bf039a062d34511cd016cd9b59">createExponentialDOSVector</a>(std::vector&lt;double&gt;&amp; data, <span class="keyword">const</span> <span class="keywordtype">double</span> mode, <span class="keyword">const</span> <span class="keywordtype">double</span> urbach_energy, std::mt19937_64&amp; gen);</div><div class="line"><a name="l00116"></a><span class="lineno">  116</span>&#160;</div><div class="line"><a name="l00122"></a><span class="lineno">  122</span>&#160;    <span class="keywordtype">void</span> <a class="code" href="namespace_utils.html#aa92dbcc79f8336fcd2d9644db1a2b0ae">createGaussianDOSVector</a>(std::vector&lt;double&gt;&amp; data, <span class="keyword">const</span> <span class="keywordtype">double</span> mean, <span class="keyword">const</span> <span class="keywordtype">double</span> stdev, std::mt19937_64&amp; gen);</div><div class="line"><a name="l00123"></a><span class="lineno">  123</span>&#160;</div><div class="line"><a name="l00129"></a><span class="lineno">  129</span>&#160;    <span class="keywordtype">bool</span> <a class="code" href="namespace_utils.html#a98a0cc670327fc21e272a07cbf5025ec">importBooleanParam</a>(<span class="keyword">const</span> std::string&amp; input, <span class="keywordtype">bool</span>&amp; error_status);</div><div class="line"><a name="l00130"></a><span class="lineno">  130</span>&#160;</div><div class="line"><a name="l00135"></a><span class="lineno">  135</span>&#160;    <span class="keywordtype">double</span> <a class="code" href="namespace_utils.html#a49411c9d4c7a065dbcf237aa27a84023">integrateData</a>(<span class="keyword">const</span> std::vector&lt;std::pair&lt;double, double&gt;&gt;&amp; data);</div><div class="line"><a name="l00136"></a><span class="lineno">  136</span>&#160;</div><div class="line"><a name="l00142"></a><span class="lineno">  142</span>&#160;    <span class="keywordtype">double</span> <a class="code" href="namespace_utils.html#af68995497777ee14d812c65991a4046f">interpolateData</a>(<span class="keyword">const</span> std::vector&lt;std::pair&lt;double, double&gt;&gt;&amp; data, <span class="keyword">const</span> <span class="keywordtype">double</span> x_val);</div><div class="line"><a name="l00143"></a><span class="lineno">  143</span>&#160;</div><div class="line"><a name="l00150"></a><span class="lineno">  150</span>&#160;    std::vector&lt;double&gt; <a class="code" href="namespace_utils.html#a71eeb04d74f890da3d27128c37fcff78">MPI_calculateVectorAvg</a>(<span class="keyword">const</span> std::vector&lt;double&gt;&amp; input_vector);</div><div class="line"><a name="l00151"></a><span class="lineno">  151</span>&#160;</div><div class="line"><a name="l00158"></a><span class="lineno">  158</span>&#160;    std::vector&lt;double&gt; <a class="code" href="namespace_utils.html#a0a17d0ad939418dc745bcfd194ce2bc1">MPI_calculateVectorSum</a>(<span class="keyword">const</span> std::vector&lt;double&gt;&amp; input_vector);</div><div class="line"><a name="l00159"></a><span class="lineno">  159</span>&#160;</div><div class="line"><a name="l00166"></a><span class="lineno">  166</span>&#160;    std::vector&lt;int&gt; <a class="code" href="namespace_utils.html#a0a17d0ad939418dc745bcfd194ce2bc1">MPI_calculateVectorSum</a>(<span class="keyword">const</span> std::vector&lt;int&gt;&amp; input_vector);</div><div class="line"><a name="l00167"></a><span class="lineno">  167</span>&#160;</div><div class="line"><a name="l00174"></a><span class="lineno">  174</span>&#160;    std::vector&lt;double&gt; <a class="code" href="namespace_utils.html#aee439dad386e2477d34968311b166c85">MPI_gatherVectors</a>(<span class="keyword">const</span> std::vector&lt;double&gt;&amp; input_vector);</div><div class="line"><a name="l00175"></a><span class="lineno">  175</span>&#160;</div><div class="line"><a name="l00182"></a><span class="lineno">  182</span>&#160;    std::vector&lt;int&gt; <a class="code" href="namespace_utils.html#aee439dad386e2477d34968311b166c85">MPI_gatherVectors</a>(<span class="keyword">const</span> std::vector&lt;int&gt;&amp; input_vector);</div><div class="line"><a name="l00183"></a><span class="lineno">  183</span>&#160;</div><div class="line"><a name="l00187"></a><span class="lineno">  187</span>&#160;    std::string <a class="code" href="namespace_utils.html#af9ceee3373ffe317f07d177cf0dfe056">removeWhitespace</a>(<span class="keyword">const</span> std::string&amp; str);</div><div class="line"><a name="l00188"></a><span class="lineno">  188</span>&#160;</div><div class="line"><a name="l00189"></a><span class="lineno">  189</span>&#160;    <span class="comment">// Template functions</span></div><div class="line"><a name="l00190"></a><span class="lineno">  190</span>&#160;</div><div class="line"><a name="l00195"></a><span class="lineno">  195</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> T&gt;</div><div class="line"><a name="l00196"></a><span class="lineno"><a class="line" href="namespace_utils.html#aa76a204af4dd4c3eb151691825de2eb2">  196</a></span>&#160;    <span class="keywordtype">double</span> <a class="code" href="namespace_utils.html#aa76a204af4dd4c3eb151691825de2eb2">array_avg</a>(<span class="keyword">const</span> T data[], <span class="keyword">const</span> <span class="keywordtype">int</span> array_size) {</div><div class="line"><a name="l00197"></a><span class="lineno">  197</span>&#160;        <span class="keywordtype">double</span> sum = 0;</div><div class="line"><a name="l00198"></a><span class="lineno">  198</span>&#160;        <span class="keywordflow">for</span> (<span class="keywordtype">int</span> i = 0; i &lt; array_size; i++) {</div><div class="line"><a name="l00199"></a><span class="lineno">  199</span>&#160;            sum += data[i];</div><div class="line"><a name="l00200"></a><span class="lineno">  200</span>&#160;        }</div><div class="line"><a name="l00201"></a><span class="lineno">  201</span>&#160;        <span class="keywordflow">return</span> sum / array_size;</div><div class="line"><a name="l00202"></a><span class="lineno">  202</span>&#160;    }</div><div class="line"><a name="l00203"></a><span class="lineno">  203</span>&#160;</div><div class="line"><a name="l00208"></a><span class="lineno">  208</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> T&gt;</div><div class="line"><a name="l00209"></a><span class="lineno"><a class="line" href="namespace_utils.html#a25d09c704b5ae03f01cf76b6de10aa19">  209</a></span>&#160;    <span class="keywordtype">double</span> <a class="code" href="namespace_utils.html#a25d09c704b5ae03f01cf76b6de10aa19">array_stdev</a>(<span class="keyword">const</span> T data[], <span class="keyword">const</span> <span class="keywordtype">int</span> array_size) {</div><div class="line"><a name="l00210"></a><span class="lineno">  210</span>&#160;        <span class="keywordtype">double</span> sum = 0;</div><div class="line"><a name="l00211"></a><span class="lineno">  211</span>&#160;        <span class="keywordtype">double</span> avg = <a class="code" href="namespace_utils.html#aa76a204af4dd4c3eb151691825de2eb2">array_avg</a>(data, array_size);</div><div class="line"><a name="l00212"></a><span class="lineno">  212</span>&#160;        <span class="keywordflow">for</span> (<span class="keywordtype">int</span> i = 0; i &lt; array_size; i++) {</div><div class="line"><a name="l00213"></a><span class="lineno">  213</span>&#160;            sum += (data[i] - avg)*(data[i] - avg);</div><div class="line"><a name="l00214"></a><span class="lineno">  214</span>&#160;        }</div><div class="line"><a name="l00215"></a><span class="lineno">  215</span>&#160;        <span class="keywordflow">return</span> sqrt(sum / (array_size - 1));</div><div class="line"><a name="l00216"></a><span class="lineno">  216</span>&#160;    }</div><div class="line"><a name="l00217"></a><span class="lineno">  217</span>&#160;</div><div class="line"><a name="l00222"></a><span class="lineno">  222</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> base_type&gt;</div><div class="line"><a name="l00223"></a><span class="lineno"><a class="line" href="namespace_utils.html#affd19edaa58a3f8425e1f7b4c9233f8a">  223</a></span>&#160;    base_type <a class="code" href="namespace_utils.html#affd19edaa58a3f8425e1f7b4c9233f8a">intpow</a>(<span class="keyword">const</span> base_type base, <span class="keyword">const</span> <span class="keywordtype">int</span> exponent) {</div><div class="line"><a name="l00224"></a><span class="lineno">  224</span>&#160;        base_type result;</div><div class="line"><a name="l00225"></a><span class="lineno">  225</span>&#160;        <span class="keywordflow">if</span> (exponent == 0) {</div><div class="line"><a name="l00226"></a><span class="lineno">  226</span>&#160;            result = 1;</div><div class="line"><a name="l00227"></a><span class="lineno">  227</span>&#160;            <span class="keywordflow">return</span> result;</div><div class="line"><a name="l00228"></a><span class="lineno">  228</span>&#160;        }</div><div class="line"><a name="l00229"></a><span class="lineno">  229</span>&#160;        result = base;</div><div class="line"><a name="l00230"></a><span class="lineno">  230</span>&#160;        <span class="keywordflow">for</span> (<span class="keywordtype">int</span> i = 1; i &lt; abs(exponent); i++) {</div><div class="line"><a name="l00231"></a><span class="lineno">  231</span>&#160;            result *= base;</div><div class="line"><a name="l00232"></a><span class="lineno">  232</span>&#160;        }</div><div class="line"><a name="l00233"></a><span class="lineno">  233</span>&#160;        <span class="keywordflow">if</span> (exponent &lt; 0) {</div><div class="line"><a name="l00234"></a><span class="lineno">  234</span>&#160;            result = 1.0 / result;</div><div class="line"><a name="l00235"></a><span class="lineno">  235</span>&#160;        }</div><div class="line"><a name="l00236"></a><span class="lineno">  236</span>&#160;        <span class="keywordflow">return</span> result;</div><div class="line"><a name="l00237"></a><span class="lineno">  237</span>&#160;    }</div><div class="line"><a name="l00238"></a><span class="lineno">  238</span>&#160;</div><div class="line"><a name="l00243"></a><span class="lineno">  243</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> T&gt;</div><div class="line"><a name="l00244"></a><span class="lineno"><a class="line" href="namespace_utils.html#ab76081fb0fa0e9e1633b1b2255db4164">  244</a></span>&#160;    <span class="keywordtype">void</span> <a class="code" href="namespace_utils.html#ab76081fb0fa0e9e1633b1b2255db4164">outputVectorToFile</a>(std::vector&lt;T&gt;&amp; vec, std::string filename) {</div><div class="line"><a name="l00245"></a><span class="lineno">  245</span>&#160;        std::ofstream outfile;</div><div class="line"><a name="l00246"></a><span class="lineno">  246</span>&#160;        outfile.open(filename);</div><div class="line"><a name="l00247"></a><span class="lineno">  247</span>&#160;        <span class="keywordflow">for</span> (<span class="keyword">auto</span> <span class="keyword">const</span> &amp;item : vec) {</div><div class="line"><a name="l00248"></a><span class="lineno">  248</span>&#160;            outfile &lt;&lt; item &lt;&lt; <span class="stringliteral">&quot;\n&quot;</span>;</div><div class="line"><a name="l00249"></a><span class="lineno">  249</span>&#160;        }</div><div class="line"><a name="l00250"></a><span class="lineno">  250</span>&#160;        outfile.close();</div><div class="line"><a name="l00251"></a><span class="lineno">  251</span>&#160;    }</div><div class="line"><a name="l00252"></a><span class="lineno">  252</span>&#160;</div><div class="line"><a name="l00257"></a><span class="lineno">  257</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> T&gt;</div><div class="line"><a name="l00258"></a><span class="lineno"><a class="line" href="namespace_utils.html#a652ab00e72bce852c2b9798ff3e1a60b">  258</a></span>&#160;    <span class="keywordtype">void</span> <a class="code" href="namespace_utils.html#ab76081fb0fa0e9e1633b1b2255db4164">outputVectorToFile</a>(std::vector&lt;std::pair&lt;T,T&gt;&gt;&amp; vec, std::string filename) {</div><div class="line"><a name="l00259"></a><span class="lineno">  259</span>&#160;        std::ofstream outfile;</div><div class="line"><a name="l00260"></a><span class="lineno">  260</span>&#160;        outfile.open(filename);</div><div class="line"><a name="l00261"></a><span class="lineno">  261</span>&#160;        <span class="keywordflow">for</span> (<span class="keyword">auto</span> <span class="keyword">const</span> &amp;item : vec) {</div><div class="line"><a name="l00262"></a><span class="lineno">  262</span>&#160;            outfile &lt;&lt; item.first &lt;&lt; <span class="stringliteral">&quot;,&quot;</span> &lt;&lt; item.second &lt;&lt; <span class="stringliteral">&quot;\n&quot;</span>;</div><div class="line"><a name="l00263"></a><span class="lineno">  263</span>&#160;        }</div><div class="line"><a name="l00264"></a><span class="lineno">  264</span>&#160;        outfile.close();</div><div class="line"><a name="l00265"></a><span class="lineno">  265</span>&#160;    }</div><div class="line"><a name="l00266"></a><span class="lineno">  266</span>&#160;</div><div class="line"><a name="l00270"></a><span class="lineno">  270</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> T&gt;</div><div class="line"><a name="l00271"></a><span class="lineno"><a class="line" href="namespace_utils.html#a5f64d00eec0b50ac5bd119652c99d01b">  271</a></span>&#160;    <span class="keywordtype">void</span> <a class="code" href="namespace_utils.html#a5f64d00eec0b50ac5bd119652c99d01b">removeDuplicates</a>(std::vector&lt;T&gt; &amp;vec) {</div><div class="line"><a name="l00272"></a><span class="lineno">  272</span>&#160;        <span class="keywordflow">if</span> ((<span class="keywordtype">int</span>)vec.size() &gt; 2) {</div><div class="line"><a name="l00273"></a><span class="lineno">  273</span>&#160;            <span class="keywordflow">for</span> (<span class="keyword">auto</span> it1 = vec.begin(); it1 != vec.end() - 2; ++it1) {</div><div class="line"><a name="l00274"></a><span class="lineno">  274</span>&#160;                <span class="keywordflow">for</span> (<span class="keyword">auto</span> it2 = it1 + 2; it2 != vec.end(); ++it2) {</div><div class="line"><a name="l00275"></a><span class="lineno">  275</span>&#160;                    <span class="keywordflow">if</span> (*it2 == *it1) {</div><div class="line"><a name="l00276"></a><span class="lineno">  276</span>&#160;                        *it2 = *(it2 - 1);</div><div class="line"><a name="l00277"></a><span class="lineno">  277</span>&#160;                    }</div><div class="line"><a name="l00278"></a><span class="lineno">  278</span>&#160;                }</div><div class="line"><a name="l00279"></a><span class="lineno">  279</span>&#160;            }</div><div class="line"><a name="l00280"></a><span class="lineno">  280</span>&#160;        }</div><div class="line"><a name="l00281"></a><span class="lineno">  281</span>&#160;        <span class="keywordflow">if</span> ((<span class="keywordtype">int</span>)vec.size() &gt; 1) {</div><div class="line"><a name="l00282"></a><span class="lineno">  282</span>&#160;            <span class="keyword">auto</span> it3 = unique(vec.begin(), vec.end());</div><div class="line"><a name="l00283"></a><span class="lineno">  283</span>&#160;            vec.resize(distance(vec.begin(), it3));</div><div class="line"><a name="l00284"></a><span class="lineno">  284</span>&#160;        }</div><div class="line"><a name="l00285"></a><span class="lineno">  285</span>&#160;    }</div><div class="line"><a name="l00286"></a><span class="lineno">  286</span>&#160;</div><div class="line"><a name="l00290"></a><span class="lineno">  290</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> T, <span class="keyword">typename</span> A&gt;</div><div class="line"><a name="l00291"></a><span class="lineno"><a class="line" href="namespace_utils.html#acbc030ce708229ea393215fe13e6377b">  291</a></span>&#160;    <span class="keywordtype">double</span> <a class="code" href="namespace_utils.html#acbc030ce708229ea393215fe13e6377b">vector_avg</a>(<span class="keyword">const</span> std::vector&lt;T, A&gt;&amp; data) {</div><div class="line"><a name="l00292"></a><span class="lineno">  292</span>&#160;        <span class="keywordflow">return</span> accumulate(data.begin(), data.end(), 0.0) / (double)data.size();</div><div class="line"><a name="l00293"></a><span class="lineno">  293</span>&#160;    }</div><div class="line"><a name="l00294"></a><span class="lineno">  294</span>&#160;</div><div class="line"><a name="l00298"></a><span class="lineno">  298</span>&#160;    <span class="keyword">template</span>&lt;<span class="keyword">typename</span> T, <span class="keyword">typename</span> A&gt;</div><div class="line"><a name="l00299"></a><span class="lineno"><a class="line" href="namespace_utils.html#a6bfa9b066d7c0967807d588024c15d4e">  299</a></span>&#160;    <span class="keywordtype">double</span> <a class="code" href="namespace_utils.html#a6bfa9b066d7c0967807d588024c15d4e">vector_stdev</a>(<span class="keyword">const</span> std::vector&lt;T, A&gt;&amp; data) {</div><div class="line"><a name="l00300"></a><span class="lineno">  300</span>&#160;        <span class="keywordtype">double</span> avg = <a class="code" href="namespace_utils.html#acbc030ce708229ea393215fe13e6377b">vector_avg</a>(data);</div><div class="line"><a name="l00301"></a><span class="lineno">  301</span>&#160;        <span class="keywordtype">double</span> sum = accumulate(data.begin(), data.end(), 0.0, [avg](<span class="keywordtype">double</span>&amp; x, <span class="keyword">const</span> T&amp; element) {</div><div class="line"><a name="l00302"></a><span class="lineno">  302</span>&#160;            <span class="keywordflow">return</span> x + (element - avg)*(element - avg);</div><div class="line"><a name="l00303"></a><span class="lineno">  303</span>&#160;        });</div><div class="line"><a name="l00304"></a><span class="lineno">  304</span>&#160;        <span class="keywordflow">return</span> sqrt(sum / (<span class="keywordtype">double</span>)((<span class="keywordtype">int</span>)data.size() - 1));</div><div class="line"><a name="l00305"></a><span class="lineno">  305</span>&#160;    }</div><div class="line"><a name="l00306"></a><span class="lineno">  306</span>&#160;}</div><div class="line"><a name="l00307"></a><span class="lineno">  307</span>&#160;</div><div class="line"><a name="l00308"></a><span class="lineno">  308</span>&#160;<span class="preprocessor">#endif // UTILS_H</span></div><div class="ttc" id="namespace_utils_html_a6bfa9b066d7c0967807d588024c15d4e"><div class="ttname"><a href="namespace_utils.html#a6bfa9b066d7c0967807d588024c15d4e">Utils::vector_stdev</a></div><div class="ttdeci">double vector_stdev(const std::vector&lt; T, A &gt; &amp;data)</div><div class="ttdoc">This template function calculates and returns the standard deviation in double format when given a ve...</div><div class="ttdef"><b>Definition:</b> Utils.h:299</div></div>
 <div class="ttc" id="struct_coords_html_a96d176173dbd5d97e7af63e1b5c0f7e1"><div class="ttname"><a href="struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1">Coords::z</a></div><div class="ttdeci">int z</div><div class="ttdoc">The z Cartesian coordinate. </div><div class="ttdef"><b>Definition:</b> Utils.h:31</div></div>
-<div class="ttc" id="namespace_utils_html_a5f64d00eec0b50ac5bd119652c99d01b"><div class="ttname"><a href="namespace_utils.html#a5f64d00eec0b50ac5bd119652c99d01b">Utils::removeDuplicates</a></div><div class="ttdeci">void removeDuplicates(std::vector&lt; T &gt; &amp;vec)</div><div class="ttdoc">This template function efficienctly removes the duplicate entries from an input vector. </div><div class="ttdef"><b>Definition:</b> Utils.h:258</div></div>
+<div class="ttc" id="namespace_utils_html_a5f64d00eec0b50ac5bd119652c99d01b"><div class="ttname"><a href="namespace_utils.html#a5f64d00eec0b50ac5bd119652c99d01b">Utils::removeDuplicates</a></div><div class="ttdeci">void removeDuplicates(std::vector&lt; T &gt; &amp;vec)</div><div class="ttdoc">This template function efficienctly removes the duplicate entries from an input vector. </div><div class="ttdef"><b>Definition:</b> Utils.h:271</div></div>
 <div class="ttc" id="struct_coords_html_a59992d986e76375f31828d32c05cd15d"><div class="ttname"><a href="struct_coords.html#a59992d986e76375f31828d32c05cd15d">Coords::x</a></div><div class="ttdeci">int x</div><div class="ttdoc">The x Cartesian coordinate. </div><div class="ttdef"><b>Definition:</b> Utils.h:27</div></div>
 <div class="ttc" id="namespace_utils_html_adcb2e98774b12bc12264034913547a2c"><div class="ttname"><a href="namespace_utils.html#adcb2e98774b12bc12264034913547a2c">Utils::calculateProbabilityHist</a></div><div class="ttdeci">std::vector&lt; std::pair&lt; double, double &gt; &gt; calculateProbabilityHist(const std::vector&lt; double &gt; &amp;data, int num_bins)</div><div class="ttdoc">Calculates the probability histogram for the input data vector using the input number of bins...</div><div class="ttdef"><b>Definition:</b> Utils.cpp:12</div></div>
-<div class="ttc" id="namespace_utils_html_a25d09c704b5ae03f01cf76b6de10aa19"><div class="ttname"><a href="namespace_utils.html#a25d09c704b5ae03f01cf76b6de10aa19">Utils::array_stdev</a></div><div class="ttdeci">double array_stdev(const T data[], const int array_size)</div><div class="ttdoc">This template function calculates and returns the standard deviation in double format when given an a...</div><div class="ttdef"><b>Definition:</b> Utils.h:196</div></div>
-<div class="ttc" id="namespace_utils_html_aa76a204af4dd4c3eb151691825de2eb2"><div class="ttname"><a href="namespace_utils.html#aa76a204af4dd4c3eb151691825de2eb2">Utils::array_avg</a></div><div class="ttdeci">double array_avg(const T data[], const int array_size)</div><div class="ttdoc">This template function calculates and returns the average value in double format when given an array ...</div><div class="ttdef"><b>Definition:</b> Utils.h:183</div></div>
-<div class="ttc" id="namespace_utils_html_a98a0cc670327fc21e272a07cbf5025ec"><div class="ttname"><a href="namespace_utils.html#a98a0cc670327fc21e272a07cbf5025ec">Utils::importBooleanParam</a></div><div class="ttdeci">bool importBooleanParam(const std::string &amp;input, bool &amp;error_status)</div><div class="ttdoc">Extracts a boolean value from a string containing &quot;true&quot; or &quot;false&quot;. </div><div class="ttdef"><b>Definition:</b> Utils.cpp:134</div></div>
+<div class="ttc" id="namespace_utils_html_a25d09c704b5ae03f01cf76b6de10aa19"><div class="ttname"><a href="namespace_utils.html#a25d09c704b5ae03f01cf76b6de10aa19">Utils::array_stdev</a></div><div class="ttdeci">double array_stdev(const T data[], const int array_size)</div><div class="ttdoc">This template function calculates and returns the standard deviation in double format when given an a...</div><div class="ttdef"><b>Definition:</b> Utils.h:209</div></div>
+<div class="ttc" id="namespace_utils_html_aa76a204af4dd4c3eb151691825de2eb2"><div class="ttname"><a href="namespace_utils.html#aa76a204af4dd4c3eb151691825de2eb2">Utils::array_avg</a></div><div class="ttdeci">double array_avg(const T data[], const int array_size)</div><div class="ttdoc">This template function calculates and returns the average value in double format when given an array ...</div><div class="ttdef"><b>Definition:</b> Utils.h:196</div></div>
+<div class="ttc" id="struct_coords_html_a5922d1783cefa759950faa50ac347191"><div class="ttname"><a href="struct_coords.html#a5922d1783cefa759950faa50ac347191">Coords::Coords</a></div><div class="ttdeci">Coords()</div><div class="ttdoc">Default constructor that creates an empty Coords object. </div><div class="ttdef"><b>Definition:</b> Utils.h:34</div></div>
+<div class="ttc" id="namespace_utils_html_a98a0cc670327fc21e272a07cbf5025ec"><div class="ttname"><a href="namespace_utils.html#a98a0cc670327fc21e272a07cbf5025ec">Utils::importBooleanParam</a></div><div class="ttdeci">bool importBooleanParam(const std::string &amp;input, bool &amp;error_status)</div><div class="ttdoc">Extracts a boolean value from a string containing &quot;true&quot; or &quot;false&quot;. </div><div class="ttdef"><b>Definition:</b> Utils.cpp:117</div></div>
 <div class="ttc" id="struct_coords_html_a7ed64d02fb7550f1506a93fcfab7f16f"><div class="ttname"><a href="struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f">Coords::y</a></div><div class="ttdeci">int y</div><div class="ttdoc">The y Cartesian coordinate. </div><div class="ttdef"><b>Definition:</b> Utils.h:29</div></div>
-<div class="ttc" id="namespace_utils_html_a49411c9d4c7a065dbcf237aa27a84023"><div class="ttname"><a href="namespace_utils.html#a49411c9d4c7a065dbcf237aa27a84023">Utils::integrateData</a></div><div class="ttdeci">double integrateData(const std::vector&lt; std::pair&lt; double, double &gt;&gt; &amp;data)</div><div class="ttdoc">Numerically integrates a vector of x-y data using the trapezoid rule. </div><div class="ttdef"><b>Definition:</b> Utils.cpp:149</div></div>
+<div class="ttc" id="namespace_utils_html_a49411c9d4c7a065dbcf237aa27a84023"><div class="ttname"><a href="namespace_utils.html#a49411c9d4c7a065dbcf237aa27a84023">Utils::integrateData</a></div><div class="ttdeci">double integrateData(const std::vector&lt; std::pair&lt; double, double &gt;&gt; &amp;data)</div><div class="ttdoc">Numerically integrates a vector of x-y data using the trapezoid rule. </div><div class="ttdef"><b>Definition:</b> Utils.cpp:132</div></div>
 <div class="ttc" id="namespace_utils_html"><div class="ttname"><a href="namespace_utils.html">Utils</a></div><div class="ttdoc">This namespace provides useful constants and utility functions. </div><div class="ttdef"><b>Definition:</b> Utils.cpp:8</div></div>
-<div class="ttc" id="struct_coords_html_ad3347f6568814df1a2b98b3cd0b78632"><div class="ttname"><a href="struct_coords.html#ad3347f6568814df1a2b98b3cd0b78632">Coords::operator==</a></div><div class="ttdeci">bool operator==(const Coords &amp;rhs) const</div><div class="ttdoc">Defines the conditions when two Coords structs are deemed to be equal. </div><div class="ttdef"><b>Definition:</b> Utils.h:44</div></div>
-<div class="ttc" id="namespace_utils_html_aee439dad386e2477d34968311b166c85"><div class="ttname"><a href="namespace_utils.html#aee439dad386e2477d34968311b166c85">Utils::MPI_gatherVectors</a></div><div class="ttdeci">std::vector&lt; double &gt; MPI_gatherVectors(const std::vector&lt; double &gt; &amp;input_vector)</div><div class="ttdoc">Uses MPI to gather vectors from separate processors to build one big vector containing all of the dat...</div><div class="ttdef"><b>Definition:</b> Utils.cpp:277</div></div>
-<div class="ttc" id="namespace_utils_html_a2ce45ade7d6d4f2995b595da3ebbaaec"><div class="ttname"><a href="namespace_utils.html#a2ce45ade7d6d4f2995b595da3ebbaaec">Utils::createGaussianDOSVector</a></div><div class="ttdeci">void createGaussianDOSVector(std::vector&lt; double &gt; &amp;data, const double mean, const double stdev, std::mt19937 &amp;gen)</div><div class="ttdoc">Creates a vector of doubles that has a Gaussian distribution. </div><div class="ttdef"><b>Definition:</b> Utils.cpp:126</div></div>
-<div class="ttc" id="namespace_utils_html_af296d2aa8f889f67fe515fc641c5f5fe"><div class="ttname"><a href="namespace_utils.html#af296d2aa8f889f67fe515fc641c5f5fe">Utils::createExponentialDOSVector</a></div><div class="ttdeci">void createExponentialDOSVector(std::vector&lt; double &gt; &amp;data, const double mode, const double urbach_energy, std::mt19937 &amp;gen)</div><div class="ttdoc">Creates a vector of doubles that has a custom asymmetric distribution with an exponential tail...</div><div class="ttdef"><b>Definition:</b> Utils.cpp:109</div></div>
-<div class="ttc" id="namespace_utils_html_a0a17d0ad939418dc745bcfd194ce2bc1"><div class="ttname"><a href="namespace_utils.html#a0a17d0ad939418dc745bcfd194ce2bc1">Utils::MPI_calculateVectorSum</a></div><div class="ttdeci">std::vector&lt; double &gt; MPI_calculateVectorSum(const std::vector&lt; double &gt; &amp;input_vector)</div><div class="ttdoc">Uses MPI to calculate the element-wise sum vector from separate vectors coming from different process...</div><div class="ttdef"><b>Definition:</b> Utils.cpp:229</div></div>
-<div class="ttc" id="namespace_utils_html_acbc030ce708229ea393215fe13e6377b"><div class="ttname"><a href="namespace_utils.html#acbc030ce708229ea393215fe13e6377b">Utils::vector_avg</a></div><div class="ttdeci">double vector_avg(const std::vector&lt; T, A &gt; &amp;data)</div><div class="ttdoc">This template function calculates and returns the average value in double format when given a vector ...</div><div class="ttdef"><b>Definition:</b> Utils.h:278</div></div>
+<div class="ttc" id="namespace_utils_html_a62ed21bf039a062d34511cd016cd9b59"><div class="ttname"><a href="namespace_utils.html#a62ed21bf039a062d34511cd016cd9b59">Utils::createExponentialDOSVector</a></div><div class="ttdeci">void createExponentialDOSVector(std::vector&lt; double &gt; &amp;data, const double mode, const double urbach_energy, std::mt19937_64 &amp;gen)</div><div class="ttdoc">Creates a vector of doubles that has a custom asymmetric distribution with an exponential tail...</div><div class="ttdef"><b>Definition:</b> Utils.cpp:92</div></div>
+<div class="ttc" id="struct_coords_html_ad3347f6568814df1a2b98b3cd0b78632"><div class="ttname"><a href="struct_coords.html#ad3347f6568814df1a2b98b3cd0b78632">Coords::operator==</a></div><div class="ttdeci">bool operator==(const Coords &amp;rhs) const</div><div class="ttdoc">Defines the conditions when two Coords structs are deemed to be equal. </div><div class="ttdef"><b>Definition:</b> Utils.h:57</div></div>
+<div class="ttc" id="namespace_utils_html_aee439dad386e2477d34968311b166c85"><div class="ttname"><a href="namespace_utils.html#aee439dad386e2477d34968311b166c85">Utils::MPI_gatherVectors</a></div><div class="ttdeci">std::vector&lt; double &gt; MPI_gatherVectors(const std::vector&lt; double &gt; &amp;input_vector)</div><div class="ttdoc">Uses MPI to gather vectors from separate processors to build one big vector containing all of the dat...</div><div class="ttdef"><b>Definition:</b> Utils.cpp:260</div></div>
+<div class="ttc" id="struct_coords_html_a246211bba85765d5d67953922070d11f"><div class="ttname"><a href="struct_coords.html#a246211bba85765d5d67953922070d11f">Coords::Coords</a></div><div class="ttdeci">Coords(const int xval, const int yval, const int zval)</div><div class="ttdoc">Constructor that creates a Coords object with the x,y,z coordinates set using the input values xval...</div><div class="ttdef"><b>Definition:</b> Utils.h:40</div></div>
+<div class="ttc" id="namespace_utils_html_aa92dbcc79f8336fcd2d9644db1a2b0ae"><div class="ttname"><a href="namespace_utils.html#aa92dbcc79f8336fcd2d9644db1a2b0ae">Utils::createGaussianDOSVector</a></div><div class="ttdeci">void createGaussianDOSVector(std::vector&lt; double &gt; &amp;data, const double mean, const double stdev, std::mt19937_64 &amp;gen)</div><div class="ttdoc">Creates a vector of doubles that has a Gaussian distribution. </div><div class="ttdef"><b>Definition:</b> Utils.cpp:109</div></div>
+<div class="ttc" id="namespace_utils_html_a0a17d0ad939418dc745bcfd194ce2bc1"><div class="ttname"><a href="namespace_utils.html#a0a17d0ad939418dc745bcfd194ce2bc1">Utils::MPI_calculateVectorSum</a></div><div class="ttdeci">std::vector&lt; double &gt; MPI_calculateVectorSum(const std::vector&lt; double &gt; &amp;input_vector)</div><div class="ttdoc">Uses MPI to calculate the element-wise sum vector from separate vectors coming from different process...</div><div class="ttdef"><b>Definition:</b> Utils.cpp:212</div></div>
+<div class="ttc" id="namespace_utils_html_acbc030ce708229ea393215fe13e6377b"><div class="ttname"><a href="namespace_utils.html#acbc030ce708229ea393215fe13e6377b">Utils::vector_avg</a></div><div class="ttdeci">double vector_avg(const std::vector&lt; T, A &gt; &amp;data)</div><div class="ttdoc">This template function calculates and returns the average value in double format when given a vector ...</div><div class="ttdef"><b>Definition:</b> Utils.h:291</div></div>
 <div class="ttc" id="struct_coords_html"><div class="ttname"><a href="struct_coords.html">Coords</a></div><div class="ttdoc">This simple struct contains Cartesian coordinates specified by integers x,y,z. </div><div class="ttdef"><b>Definition:</b> Utils.h:25</div></div>
-<div class="ttc" id="namespace_utils_html_af68995497777ee14d812c65991a4046f"><div class="ttname"><a href="namespace_utils.html#af68995497777ee14d812c65991a4046f">Utils::interpolateData</a></div><div class="ttdeci">double interpolateData(const std::vector&lt; std::pair&lt; double, double &gt;&gt; &amp;data, const double x_val)</div><div class="ttdoc">Linearly interpolates an x-y data set to determine the interpolated y-value corresponding to an input...</div><div class="ttdef"><b>Definition:</b> Utils.cpp:157</div></div>
-<div class="ttc" id="struct_coords_html_aaea2c566feec4e4bf56b27a34568be76"><div class="ttname"><a href="struct_coords.html#aaea2c566feec4e4bf56b27a34568be76">Coords::operator!=</a></div><div class="ttdeci">bool operator!=(const Coords &amp;rhs) const</div><div class="ttdoc">Defines the conditions when two Coords structs are deemed to be unequal. </div><div class="ttdef"><b>Definition:</b> Utils.h:49</div></div>
-<div class="ttc" id="namespace_utils_html_af9ceee3373ffe317f07d177cf0dfe056"><div class="ttname"><a href="namespace_utils.html#af9ceee3373ffe317f07d177cf0dfe056">Utils::removeWhitespace</a></div><div class="ttdeci">std::string removeWhitespace(const std::string &amp;str_input)</div><div class="ttdoc">Removes all spaces and ta characters in a string. </div><div class="ttdef"><b>Definition:</b> Utils.cpp:367</div></div>
-<div class="ttc" id="struct_coords_html_a88de3a6ee710766eb9c9444cee45a9f3"><div class="ttname"><a href="struct_coords.html#a88de3a6ee710766eb9c9444cee45a9f3">Coords::setXYZ</a></div><div class="ttdeci">void setXYZ(const int xval, const int yval, const int zval)</div><div class="ttdoc">Sets the x,y,z coordinates using the input values xval, yval, and zval. </div><div class="ttdef"><b>Definition:</b> Utils.h:37</div></div>
-<div class="ttc" id="namespace_utils_html_a71eeb04d74f890da3d27128c37fcff78"><div class="ttname"><a href="namespace_utils.html#a71eeb04d74f890da3d27128c37fcff78">Utils::MPI_calculateVectorAvg</a></div><div class="ttdeci">std::vector&lt; double &gt; MPI_calculateVectorAvg(const std::vector&lt; double &gt; &amp;input_vector)</div><div class="ttdoc">Uses MPI to calculate the element-wise average vector from separate vectors coming from different pro...</div><div class="ttdef"><b>Definition:</b> Utils.cpp:170</div></div>
-<div class="ttc" id="namespace_utils_html_ab76081fb0fa0e9e1633b1b2255db4164"><div class="ttname"><a href="namespace_utils.html#ab76081fb0fa0e9e1633b1b2255db4164">Utils::outputVectorToFile</a></div><div class="ttdeci">void outputVectorToFile(std::vector&lt; T &gt; &amp;vec, std::string filename)</div><div class="ttdoc">This template function outputs the input data vector to a file with the specified filename...</div><div class="ttdef"><b>Definition:</b> Utils.h:231</div></div>
-<div class="ttc" id="namespace_utils_html_affd19edaa58a3f8425e1f7b4c9233f8a"><div class="ttname"><a href="namespace_utils.html#affd19edaa58a3f8425e1f7b4c9233f8a">Utils::intpow</a></div><div class="ttdeci">base_type intpow(const base_type base, const int exponent)</div><div class="ttdoc">This template function calculates and returns the results of an integer power operation on a base num...</div><div class="ttdef"><b>Definition:</b> Utils.h:210</div></div>
+<div class="ttc" id="namespace_utils_html_af68995497777ee14d812c65991a4046f"><div class="ttname"><a href="namespace_utils.html#af68995497777ee14d812c65991a4046f">Utils::interpolateData</a></div><div class="ttdeci">double interpolateData(const std::vector&lt; std::pair&lt; double, double &gt;&gt; &amp;data, const double x_val)</div><div class="ttdoc">Linearly interpolates an x-y data set to determine the interpolated y-value corresponding to an input...</div><div class="ttdef"><b>Definition:</b> Utils.cpp:140</div></div>
+<div class="ttc" id="struct_coords_html_aaea2c566feec4e4bf56b27a34568be76"><div class="ttname"><a href="struct_coords.html#aaea2c566feec4e4bf56b27a34568be76">Coords::operator!=</a></div><div class="ttdeci">bool operator!=(const Coords &amp;rhs) const</div><div class="ttdoc">Defines the conditions when two Coords structs are deemed to be unequal. </div><div class="ttdef"><b>Definition:</b> Utils.h:62</div></div>
+<div class="ttc" id="namespace_utils_html_af9ceee3373ffe317f07d177cf0dfe056"><div class="ttname"><a href="namespace_utils.html#af9ceee3373ffe317f07d177cf0dfe056">Utils::removeWhitespace</a></div><div class="ttdeci">std::string removeWhitespace(const std::string &amp;str_input)</div><div class="ttdoc">Removes all spaces and ta characters in a string. </div><div class="ttdef"><b>Definition:</b> Utils.cpp:350</div></div>
+<div class="ttc" id="struct_coords_html_a88de3a6ee710766eb9c9444cee45a9f3"><div class="ttname"><a href="struct_coords.html#a88de3a6ee710766eb9c9444cee45a9f3">Coords::setXYZ</a></div><div class="ttdeci">void setXYZ(const int xval, const int yval, const int zval)</div><div class="ttdoc">Sets the x,y,z coordinates using the input values xval, yval, and zval. </div><div class="ttdef"><b>Definition:</b> Utils.h:50</div></div>
+<div class="ttc" id="namespace_utils_html_a71eeb04d74f890da3d27128c37fcff78"><div class="ttname"><a href="namespace_utils.html#a71eeb04d74f890da3d27128c37fcff78">Utils::MPI_calculateVectorAvg</a></div><div class="ttdeci">std::vector&lt; double &gt; MPI_calculateVectorAvg(const std::vector&lt; double &gt; &amp;input_vector)</div><div class="ttdoc">Uses MPI to calculate the element-wise average vector from separate vectors coming from different pro...</div><div class="ttdef"><b>Definition:</b> Utils.cpp:153</div></div>
+<div class="ttc" id="namespace_utils_html_ab76081fb0fa0e9e1633b1b2255db4164"><div class="ttname"><a href="namespace_utils.html#ab76081fb0fa0e9e1633b1b2255db4164">Utils::outputVectorToFile</a></div><div class="ttdeci">void outputVectorToFile(std::vector&lt; T &gt; &amp;vec, std::string filename)</div><div class="ttdoc">This template function outputs the input data vector to a file with the specified filename...</div><div class="ttdef"><b>Definition:</b> Utils.h:244</div></div>
+<div class="ttc" id="namespace_utils_html_affd19edaa58a3f8425e1f7b4c9233f8a"><div class="ttname"><a href="namespace_utils.html#affd19edaa58a3f8425e1f7b4c9233f8a">Utils::intpow</a></div><div class="ttdeci">base_type intpow(const base_type base, const int exponent)</div><div class="ttdoc">This template function calculates and returns the results of an integer power operation on a base num...</div><div class="ttdef"><b>Definition:</b> Utils.h:223</div></div>
 </div><!-- fragment --></div><!-- contents -->
 </div><!-- doc-content -->
 <!-- start footer part -->
diff --git a/docs/class_lattice-members.html b/docs/class_lattice-members.html
index d76109f..4ce5f40 100644
--- a/docs/class_lattice-members.html
+++ b/docs/class_lattice-members.html
@@ -103,29 +103,30 @@
   <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#a76b38079e102e17c79b13a3398a404a0">calculateDZ</a>(const Coords &amp;coords_initial, const Coords &amp;coords_dest) const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
   <tr><td class="entry"><a class="el" href="class_lattice.html#a3f51b0b41cf0e43e0469320310494a1e">calculateLatticeDistanceSquared</a>(const Coords &amp;coords_start, const Coords &amp;coords_dest) const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
   <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#ad0592298c4b92e9e84a768b95cd6d0f0">checkMoveValidity</a>(const Coords &amp;coords_initial, const int i, const int j, const int k) const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_lattice.html#a97a1b4f24cd40b81ed63aa2d7713b63b">clearOccupancy</a>(const Coords &amp;coords)</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#a9fbb3c8bc23999ff685b6837beb62606">generateRandomCoords</a>()</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_lattice.html#ab78435e50e3bf9f376c04fc305785bb4">generateRandomX</a>()</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#a180a9d79a40b1a0a092c8ab489569700">generateRandomY</a>()</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_lattice.html#a96006397a6ab389fb1eee87fde6e2165">generateRandomZ</a>()</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#aaa0cba3ab33ac620d9b9f9508c56d1ac">getHeight</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_lattice.html#a4b43b67a36fcd3dfe62c9eeaffa561d2">getLength</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#a4be17e9123f7737387991a9d1a8b87b3">getNumSites</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_lattice.html#a74a170b841ad1b74dad43519d37e9eaf">getSiteCoords</a>(long int site_index)</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#a60431f6504a253d47acb0b02f524571c">getSiteIndex</a>(const Coords &amp;coords) const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_lattice.html#a46f7d12855d24e1bdd02814621b0a178">getSiteIt</a>(const Coords &amp;coords)</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#ac6963a6b2b4b8d96d3417f6e9c2a509d">getUnitSize</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_lattice.html#a46f9cec33419459b64ff0efdf47a38b9">getVolume</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#aeb60d2b8bfb02d9da8bef463f0d41428">getWidth</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_lattice.html#a2b0a88048fae662aa71386a3a123a260">init</a>(const Parameters_Lattice &amp;params, std::mt19937 *generator_ptr)</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#a4d37afb6ad4c67f4f6462c2f6d5c337d">isOccupied</a>(const Coords &amp;coords) const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_lattice.html#accf3b995e0d0cb422907728a29b1b523">isXPeriodic</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#ac3192acefb019c5258143a6c758b3e48">isYPeriodic</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_lattice.html#ad7dd1b12a253e506aba5cedb57bf86ea">isZPeriodic</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#a70a5cebc3c0c5a0f609be0592e7cc117">Lattice</a>()</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_lattice.html#aa1f65735ecbd750ec04b6413b4d47316">outputLatticeOccupancy</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#a515b8bc548ef4a87c3495a7352a60399">setOccupied</a>(const Coords &amp;coords)</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_lattice.html#a59546ec4301871897ba5adfda1126741">setSitePointers</a>(const std::vector&lt; Site *&gt; &amp;input_ptrs)</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_lattice.html#abf954e8213010ab8aeac7a0b93a869bc">chooseRandomUnoccupiedNeighbor</a>(const Coords &amp;coords_i)</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#a97a1b4f24cd40b81ed63aa2d7713b63b">clearOccupancy</a>(const Coords &amp;coords)</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_lattice.html#a9fbb3c8bc23999ff685b6837beb62606">generateRandomCoords</a>()</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#ab78435e50e3bf9f376c04fc305785bb4">generateRandomX</a>()</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_lattice.html#a180a9d79a40b1a0a092c8ab489569700">generateRandomY</a>()</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#a96006397a6ab389fb1eee87fde6e2165">generateRandomZ</a>()</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_lattice.html#aaa0cba3ab33ac620d9b9f9508c56d1ac">getHeight</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#a4b43b67a36fcd3dfe62c9eeaffa561d2">getLength</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_lattice.html#a4be17e9123f7737387991a9d1a8b87b3">getNumSites</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#a74a170b841ad1b74dad43519d37e9eaf">getSiteCoords</a>(long int site_index)</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_lattice.html#a60431f6504a253d47acb0b02f524571c">getSiteIndex</a>(const Coords &amp;coords) const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#a46f7d12855d24e1bdd02814621b0a178">getSiteIt</a>(const Coords &amp;coords)</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_lattice.html#ac6963a6b2b4b8d96d3417f6e9c2a509d">getUnitSize</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#a46f9cec33419459b64ff0efdf47a38b9">getVolume</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_lattice.html#aeb60d2b8bfb02d9da8bef463f0d41428">getWidth</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#ab7322e5340badb9df4d208554fd90a89">init</a>(const Parameters_Lattice &amp;params, std::mt19937_64 *generator_ptr)</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_lattice.html#a4d37afb6ad4c67f4f6462c2f6d5c337d">isOccupied</a>(const Coords &amp;coords) const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#accf3b995e0d0cb422907728a29b1b523">isXPeriodic</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_lattice.html#ac3192acefb019c5258143a6c758b3e48">isYPeriodic</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#ad7dd1b12a253e506aba5cedb57bf86ea">isZPeriodic</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_lattice.html#a70a5cebc3c0c5a0f609be0592e7cc117">Lattice</a>()</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#aa1f65735ecbd750ec04b6413b4d47316">outputLatticeOccupancy</a>() const</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_lattice.html#a515b8bc548ef4a87c3495a7352a60399">setOccupied</a>(const Coords &amp;coords)</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_lattice.html#a59546ec4301871897ba5adfda1126741">setSitePointers</a>(const std::vector&lt; Site *&gt; &amp;input_ptrs)</td><td class="entry"><a class="el" href="class_lattice.html">Lattice</a></td><td class="entry"></td></tr>
 </table></div><!-- contents -->
 </div><!-- doc-content -->
 <!-- start footer part -->
diff --git a/docs/class_lattice.html b/docs/class_lattice.html
index 1abadae..b8bf9e1 100644
--- a/docs/class_lattice.html
+++ b/docs/class_lattice.html
@@ -105,9 +105,9 @@
 <tr class="memitem:a70a5cebc3c0c5a0f609be0592e7cc117"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lattice.html#a70a5cebc3c0c5a0f609be0592e7cc117">Lattice</a> ()</td></tr>
 <tr class="memdesc:a70a5cebc3c0c5a0f609be0592e7cc117"><td class="mdescLeft">&#160;</td><td class="mdescRight">Default constructor that creates an empty <a class="el" href="class_lattice.html" title="This class contains the properties of a three-dimensional lattice and the functions needed to interac...">Lattice</a> object.  <a href="#a70a5cebc3c0c5a0f609be0592e7cc117">More...</a><br /></td></tr>
 <tr class="separator:a70a5cebc3c0c5a0f609be0592e7cc117"><td class="memSeparator" colspan="2">&#160;</td></tr>
-<tr class="memitem:a2b0a88048fae662aa71386a3a123a260"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lattice.html#a2b0a88048fae662aa71386a3a123a260">init</a> (const <a class="el" href="struct_parameters___lattice.html">Parameters_Lattice</a> &amp;params, std::mt19937 *generator_ptr)</td></tr>
-<tr class="memdesc:a2b0a88048fae662aa71386a3a123a260"><td class="mdescLeft">&#160;</td><td class="mdescRight">Initializes the <a class="el" href="class_lattice.html" title="This class contains the properties of a three-dimensional lattice and the functions needed to interac...">Lattice</a> object using the provided <a class="el" href="struct_parameters___lattice.html" title="This struct contains all of the main input parameters needed by the Lattice class. ">Parameters_Lattice</a> input parameter struct.  <a href="#a2b0a88048fae662aa71386a3a123a260">More...</a><br /></td></tr>
-<tr class="separator:a2b0a88048fae662aa71386a3a123a260"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ab7322e5340badb9df4d208554fd90a89"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lattice.html#ab7322e5340badb9df4d208554fd90a89">init</a> (const <a class="el" href="struct_parameters___lattice.html">Parameters_Lattice</a> &amp;params, std::mt19937_64 *generator_ptr)</td></tr>
+<tr class="memdesc:ab7322e5340badb9df4d208554fd90a89"><td class="mdescLeft">&#160;</td><td class="mdescRight">Initializes the <a class="el" href="class_lattice.html" title="This class contains the properties of a three-dimensional lattice and the functions needed to interac...">Lattice</a> object using the provided <a class="el" href="struct_parameters___lattice.html" title="This struct contains all of the main input parameters needed by the Lattice class. ">Parameters_Lattice</a> input parameter struct.  <a href="#ab7322e5340badb9df4d208554fd90a89">More...</a><br /></td></tr>
+<tr class="separator:ab7322e5340badb9df4d208554fd90a89"><td class="memSeparator" colspan="2">&#160;</td></tr>
 <tr class="memitem:aa6b80d6264bfc23ae5fea39abd2557d5"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lattice.html#aa6b80d6264bfc23ae5fea39abd2557d5">calculateDestinationCoords</a> (const <a class="el" href="struct_coords.html">Coords</a> &amp;coords_initial, const int i, const int j, const int k, <a class="el" href="struct_coords.html">Coords</a> &amp;coords_dest) const</td></tr>
 <tr class="memdesc:aa6b80d6264bfc23ae5fea39abd2557d5"><td class="mdescLeft">&#160;</td><td class="mdescRight">Calculates the destination coordinates when given the starting coordinates and the displacement vector (i,j,k).  <a href="#aa6b80d6264bfc23ae5fea39abd2557d5">More...</a><br /></td></tr>
 <tr class="separator:aa6b80d6264bfc23ae5fea39abd2557d5"><td class="memSeparator" colspan="2">&#160;</td></tr>
@@ -135,6 +135,9 @@
 <tr class="memitem:ad0592298c4b92e9e84a768b95cd6d0f0"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lattice.html#ad0592298c4b92e9e84a768b95cd6d0f0">checkMoveValidity</a> (const <a class="el" href="struct_coords.html">Coords</a> &amp;coords_initial, const int i, const int j, const int k) const</td></tr>
 <tr class="memdesc:ad0592298c4b92e9e84a768b95cd6d0f0"><td class="mdescLeft">&#160;</td><td class="mdescRight">Checks to see if a generic move operation from the designated initial coordinates to a destination position specified by the displacement vector (i,j,k) is possible.  <a href="#ad0592298c4b92e9e84a768b95cd6d0f0">More...</a><br /></td></tr>
 <tr class="separator:ad0592298c4b92e9e84a768b95cd6d0f0"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:abf954e8213010ab8aeac7a0b93a869bc"><td class="memItemLeft" align="right" valign="top"><a class="el" href="struct_coords.html">Coords</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lattice.html#abf954e8213010ab8aeac7a0b93a869bc">chooseRandomUnoccupiedNeighbor</a> (const <a class="el" href="struct_coords.html">Coords</a> &amp;coords_i)</td></tr>
+<tr class="memdesc:abf954e8213010ab8aeac7a0b93a869bc"><td class="mdescLeft">&#160;</td><td class="mdescRight">Randomly selects a valid, unoccupied nearest neighbor site.  <a href="#abf954e8213010ab8aeac7a0b93a869bc">More...</a><br /></td></tr>
+<tr class="separator:abf954e8213010ab8aeac7a0b93a869bc"><td class="memSeparator" colspan="2">&#160;</td></tr>
 <tr class="memitem:a97a1b4f24cd40b81ed63aa2d7713b63b"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lattice.html#a97a1b4f24cd40b81ed63aa2d7713b63b">clearOccupancy</a> (const <a class="el" href="struct_coords.html">Coords</a> &amp;coords)</td></tr>
 <tr class="memdesc:a97a1b4f24cd40b81ed63aa2d7713b63b"><td class="mdescLeft">&#160;</td><td class="mdescRight">Clears the occupancy of the site located at the specified coordinates.  <a href="#a97a1b4f24cd40b81ed63aa2d7713b63b">More...</a><br /></td></tr>
 <tr class="separator:a97a1b4f24cd40b81ed63aa2d7713b63b"><td class="memSeparator" colspan="2">&#160;</td></tr>
@@ -628,6 +631,35 @@ <h2 class="memtitle"><span class="permalink"><a href="#ad0592298c4b92e9e84a768b9
 <dd>
 false if a move event is not possible. </dd></dl>
 
+</div>
+</div>
+<a id="abf954e8213010ab8aeac7a0b93a869bc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abf954e8213010ab8aeac7a0b93a869bc">&#9670;&nbsp;</a></span>chooseRandomUnoccupiedNeighbor()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="struct_coords.html">Coords</a> Lattice::chooseRandomUnoccupiedNeighbor </td>
+          <td>(</td>
+          <td class="paramtype">const <a class="el" href="struct_coords.html">Coords</a> &amp;&#160;</td>
+          <td class="paramname"><em>coords_i</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Randomly selects a valid, unoccupied nearest neighbor site. </p>
+<p>Will choose a site across a periodic boundary if periodic boundaries are enabled. </p><dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">coords_i</td><td>is the <a class="el" href="struct_coords.html" title="This simple struct contains Cartesian coordinates specified by integers x,y,z. ">Coords</a> struct that designates the starting coordinates. </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>a <a class="el" href="struct_coords.html" title="This simple struct contains Cartesian coordinates specified by integers x,y,z. ">Coords</a> struct that represents the selected unoccupied nearest neighbor site. </dd>
+<dd>
+{-1,-1,-1} if there is no valid unoccupied neighbor </dd></dl>
+
 </div>
 </div>
 <a id="a97a1b4f24cd40b81ed63aa2d7713b63b"></a>
@@ -919,8 +951,8 @@ <h2 class="memtitle"><span class="permalink"><a href="#aeb60d2b8bfb02d9da8bef463
 
 </div>
 </div>
-<a id="a2b0a88048fae662aa71386a3a123a260"></a>
-<h2 class="memtitle"><span class="permalink"><a href="#a2b0a88048fae662aa71386a3a123a260">&#9670;&nbsp;</a></span>init()</h2>
+<a id="ab7322e5340badb9df4d208554fd90a89"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab7322e5340badb9df4d208554fd90a89">&#9670;&nbsp;</a></span>init()</h2>
 
 <div class="memitem">
 <div class="memproto">
@@ -934,7 +966,7 @@ <h2 class="memtitle"><span class="permalink"><a href="#a2b0a88048fae662aa71386a3
         <tr>
           <td class="paramkey"></td>
           <td></td>
-          <td class="paramtype">std::mt19937 *&#160;</td>
+          <td class="paramtype">std::mt19937_64 *&#160;</td>
           <td class="paramname"><em>generator_ptr</em>&#160;</td>
         </tr>
         <tr>
diff --git a/docs/class_lattice.js b/docs/class_lattice.js
index ea4bd74..b7cb893 100644
--- a/docs/class_lattice.js
+++ b/docs/class_lattice.js
@@ -10,6 +10,7 @@ var class_lattice =
     [ "calculateDZ", "class_lattice.html#a76b38079e102e17c79b13a3398a404a0", null ],
     [ "calculateLatticeDistanceSquared", "class_lattice.html#a3f51b0b41cf0e43e0469320310494a1e", null ],
     [ "checkMoveValidity", "class_lattice.html#ad0592298c4b92e9e84a768b95cd6d0f0", null ],
+    [ "chooseRandomUnoccupiedNeighbor", "class_lattice.html#abf954e8213010ab8aeac7a0b93a869bc", null ],
     [ "clearOccupancy", "class_lattice.html#a97a1b4f24cd40b81ed63aa2d7713b63b", null ],
     [ "generateRandomCoords", "class_lattice.html#a9fbb3c8bc23999ff685b6837beb62606", null ],
     [ "generateRandomX", "class_lattice.html#ab78435e50e3bf9f376c04fc305785bb4", null ],
@@ -24,7 +25,7 @@ var class_lattice =
     [ "getUnitSize", "class_lattice.html#ac6963a6b2b4b8d96d3417f6e9c2a509d", null ],
     [ "getVolume", "class_lattice.html#a46f9cec33419459b64ff0efdf47a38b9", null ],
     [ "getWidth", "class_lattice.html#aeb60d2b8bfb02d9da8bef463f0d41428", null ],
-    [ "init", "class_lattice.html#a2b0a88048fae662aa71386a3a123a260", null ],
+    [ "init", "class_lattice.html#ab7322e5340badb9df4d208554fd90a89", null ],
     [ "isOccupied", "class_lattice.html#a4d37afb6ad4c67f4f6462c2f6d5c337d", null ],
     [ "isXPeriodic", "class_lattice.html#accf3b995e0d0cb422907728a29b1b523", null ],
     [ "isYPeriodic", "class_lattice.html#ac3192acefb019c5258143a6c758b3e48", null ],
diff --git a/docs/class_simulation-members.html b/docs/class_simulation-members.html
index b6814ed..1885b3c 100644
--- a/docs/class_simulation-members.html
+++ b/docs/class_simulation-members.html
@@ -102,30 +102,31 @@
   <tr><td class="entry"><a class="el" href="class_simulation.html#a954f41f4332dabda0fecea5d72151988">error_msg</a></td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
   <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a48e9e82f9dac1acec5d063a9f6f6115e">executeNextEvent</a>()=0</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">pure virtual</span></td></tr>
   <tr><td class="entry"><a class="el" href="class_simulation.html#a662702acf2d446dbdef0e1c87bf21038">findRecalcObjects</a>(const Coords &amp;coords_start, const Coords &amp;coords_dest) const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a4c1d9071749e0fd93e70380cafb28417">generator</a></td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a269659fa336a5563e2ccfe2db1654ba9">generator</a></td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
   <tr><td class="entry"><a class="el" href="class_simulation.html#aec6a6e1a80eb566685e4d257e6f872c5">getAllEventPtrs</a>() const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
   <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a620684b9ac1fb07344c4c2237ed9f352">getAllObjectPtrs</a>() const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
   <tr><td class="entry"><a class="el" href="class_simulation.html#a03d249f04c0921c938d68337dfc65f56">getErrorMessage</a>() const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
   <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#aff40f268758bd9a0f390a649fc45c05e">getId</a>() const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
   <tr><td class="entry"><a class="el" href="class_simulation.html#a7d88f18a1ba988d7e77b8be8de5b10d1">getN_events</a>() const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
   <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a52cb5564151421cbefaca56357738de7">getN_events_executed</a>() const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_simulation.html#ac00bce7c792fb67a75395c46c03efe0a">getTemp</a>() const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a391ac262089c8bda8e76ce930b1db88b">getTime</a>() const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_simulation.html#a623c3fbc431ab74c2d2b2374a3b5a3a7">getVolume</a>() const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#af88e5e0634b373ba28f1dd87670725a6">init</a>(const Parameters_Simulation &amp;params, const int id)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_simulation.html#ac7c8a49a4cc506b850891480e0aae512">isLoggingEnabled</a>() const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#afb2cf4feeb4d8292eeba8f9ef393c6a4">lattice</a></td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
-  <tr><td class="entry"><a class="el" href="class_simulation.html#a741321a0bbc89d51b969abda469e6f96">Logfile</a></td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a59666ceba048bec35557cb8b691d24d9">moveObject</a>(Object *object_ptr, const Coords &amp;coords_dest)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
-  <tr><td class="entry"><a class="el" href="class_simulation.html#a938de951b2766c6fb2b00cf9714caffa">rand01</a>()</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a3a4808231d4760f0ab30ea39b6a67e8c">removeEvent</a>(Event *event_ptr)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
-  <tr><td class="entry"><a class="el" href="class_simulation.html#a39da17feb9b487c05c9a834def44972f">removeObject</a>(Object *object_ptr)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a0f06c75c9dd6be20a3911781b48fd467">setErrorMessage</a>(const std::string &amp;input_msg)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
-  <tr><td class="entry"><a class="el" href="class_simulation.html#a1a825b9da67da43104137662694655bd">setGeneratorSeed</a>(const int seed)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a43ca861e2514feb7f93bf18ea3b73385">setObjectEvent</a>(const Object *object_ptr, Event *event_ptr)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
-  <tr><td class="entry"><a class="el" href="class_simulation.html#aae315f0881f0b385c566f96beb01d3f6">setTime</a>(const double input_time)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
-  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a5b224cc5b36bcc8eb29689aff223de41">Simulation</a>()</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
-  <tr><td class="entry"><a class="el" href="class_simulation.html#a80fad3f57dfaf195a36f7bc49bc88279">~Simulation</a>()</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">virtual</span></td></tr>
+  <tr><td class="entry"><a class="el" href="class_simulation.html#ab07386326b1844df84464abe30927bf5">getN_objects_created</a>() const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#ac00bce7c792fb67a75395c46c03efe0a">getTemp</a>() const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_simulation.html#a391ac262089c8bda8e76ce930b1db88b">getTime</a>() const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a623c3fbc431ab74c2d2b2374a3b5a3a7">getVolume</a>() const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_simulation.html#af88e5e0634b373ba28f1dd87670725a6">init</a>(const Parameters_Simulation &amp;params, const int id)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#ac7c8a49a4cc506b850891480e0aae512">isLoggingEnabled</a>() const</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_simulation.html#afb2cf4feeb4d8292eeba8f9ef393c6a4">lattice</a></td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a741321a0bbc89d51b969abda469e6f96">Logfile</a></td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+  <tr><td class="entry"><a class="el" href="class_simulation.html#a59666ceba048bec35557cb8b691d24d9">moveObject</a>(Object *object_ptr, const Coords &amp;coords_dest)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a938de951b2766c6fb2b00cf9714caffa">rand01</a>()</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_simulation.html#a3a4808231d4760f0ab30ea39b6a67e8c">removeEvent</a>(Event *event_ptr)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a39da17feb9b487c05c9a834def44972f">removeObject</a>(Object *object_ptr)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+  <tr><td class="entry"><a class="el" href="class_simulation.html#a0f06c75c9dd6be20a3911781b48fd467">setErrorMessage</a>(const std::string &amp;input_msg)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a1a825b9da67da43104137662694655bd">setGeneratorSeed</a>(const int seed)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="class_simulation.html#a43ca861e2514feb7f93bf18ea3b73385">setObjectEvent</a>(const Object *object_ptr, Event *event_ptr)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#aae315f0881f0b385c566f96beb01d3f6">setTime</a>(const double input_time)</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+  <tr><td class="entry"><a class="el" href="class_simulation.html#a5b224cc5b36bcc8eb29689aff223de41">Simulation</a>()</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="class_simulation.html#a80fad3f57dfaf195a36f7bc49bc88279">~Simulation</a>()</td><td class="entry"><a class="el" href="class_simulation.html">Simulation</a></td><td class="entry"><span class="mlabel">virtual</span></td></tr>
 </table></div><!-- contents -->
 </div><!-- doc-content -->
 <!-- start footer part -->
diff --git a/docs/class_simulation.html b/docs/class_simulation.html
index 434a747..c0d5f61 100644
--- a/docs/class_simulation.html
+++ b/docs/class_simulation.html
@@ -130,6 +130,10 @@
 long int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_simulation.html#a52cb5564151421cbefaca56357738de7">getN_events_executed</a> () const</td></tr>
 <tr class="memdesc:a52cb5564151421cbefaca56357738de7"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets the number of events that have been executed in the simulation. <br /></td></tr>
 <tr class="separator:a52cb5564151421cbefaca56357738de7"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ab07386326b1844df84464abe30927bf5"><td class="memItemLeft" align="right" valign="top"><a id="ab07386326b1844df84464abe30927bf5"></a>
+long int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_simulation.html#ab07386326b1844df84464abe30927bf5">getN_objects_created</a> () const</td></tr>
+<tr class="memdesc:ab07386326b1844df84464abe30927bf5"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets the number of objects that have been created in the simulation. <br /></td></tr>
+<tr class="separator:ab07386326b1844df84464abe30927bf5"><td class="memSeparator" colspan="2">&#160;</td></tr>
 <tr class="memitem:aff40f268758bd9a0f390a649fc45c05e"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_simulation.html#aff40f268758bd9a0f390a649fc45c05e">getId</a> () const</td></tr>
 <tr class="memdesc:aff40f268758bd9a0f390a649fc45c05e"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets the processor ID number for the processor that is running the simulation.  <a href="#aff40f268758bd9a0f390a649fc45c05e">More...</a><br /></td></tr>
 <tr class="separator:aff40f268758bd9a0f390a649fc45c05e"><td class="memSeparator" colspan="2">&#160;</td></tr>
@@ -199,10 +203,10 @@
 </table><table class="memberdecls">
 <tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
 Protected Attributes</h2></td></tr>
-<tr class="memitem:a4c1d9071749e0fd93e70380cafb28417"><td class="memItemLeft" align="right" valign="top"><a id="a4c1d9071749e0fd93e70380cafb28417"></a>
-std::mt19937&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_simulation.html#a4c1d9071749e0fd93e70380cafb28417">generator</a></td></tr>
-<tr class="memdesc:a4c1d9071749e0fd93e70380cafb28417"><td class="mdescLeft">&#160;</td><td class="mdescRight">Mersenne Twister random number generator. <br /></td></tr>
-<tr class="separator:a4c1d9071749e0fd93e70380cafb28417"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a269659fa336a5563e2ccfe2db1654ba9"><td class="memItemLeft" align="right" valign="top"><a id="a269659fa336a5563e2ccfe2db1654ba9"></a>
+std::mt19937_64&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_simulation.html#a269659fa336a5563e2ccfe2db1654ba9">generator</a></td></tr>
+<tr class="memdesc:a269659fa336a5563e2ccfe2db1654ba9"><td class="mdescLeft">&#160;</td><td class="mdescRight">Mersenne Twister random number generator. <br /></td></tr>
+<tr class="separator:a269659fa336a5563e2ccfe2db1654ba9"><td class="memSeparator" colspan="2">&#160;</td></tr>
 <tr class="memitem:a741321a0bbc89d51b969abda469e6f96"><td class="memItemLeft" align="right" valign="top"><a id="a741321a0bbc89d51b969abda469e6f96"></a>
 std::ofstream *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_simulation.html#a741321a0bbc89d51b969abda469e6f96">Logfile</a></td></tr>
 <tr class="memdesc:a741321a0bbc89d51b969abda469e6f96"><td class="mdescLeft">&#160;</td><td class="mdescRight">Pointer to an output file stream that is used to print log messages to a logfile when logging is enabled. <br /></td></tr>
diff --git a/docs/class_simulation.js b/docs/class_simulation.js
index b58c722..5220e1c 100644
--- a/docs/class_simulation.js
+++ b/docs/class_simulation.js
@@ -14,6 +14,7 @@ var class_simulation =
     [ "getId", "class_simulation.html#aff40f268758bd9a0f390a649fc45c05e", null ],
     [ "getN_events", "class_simulation.html#a7d88f18a1ba988d7e77b8be8de5b10d1", null ],
     [ "getN_events_executed", "class_simulation.html#a52cb5564151421cbefaca56357738de7", null ],
+    [ "getN_objects_created", "class_simulation.html#ab07386326b1844df84464abe30927bf5", null ],
     [ "getTemp", "class_simulation.html#ac00bce7c792fb67a75395c46c03efe0a", null ],
     [ "getTime", "class_simulation.html#a391ac262089c8bda8e76ce930b1db88b", null ],
     [ "getVolume", "class_simulation.html#a623c3fbc431ab74c2d2b2374a3b5a3a7", null ],
@@ -29,7 +30,7 @@ var class_simulation =
     [ "setTime", "class_simulation.html#aae315f0881f0b385c566f96beb01d3f6", null ],
     [ "Error_found", "class_simulation.html#a7f4615a7898fb83d09be5e7fad92bb47", null ],
     [ "error_msg", "class_simulation.html#a954f41f4332dabda0fecea5d72151988", null ],
-    [ "generator", "class_simulation.html#a4c1d9071749e0fd93e70380cafb28417", null ],
+    [ "generator", "class_simulation.html#a269659fa336a5563e2ccfe2db1654ba9", null ],
     [ "lattice", "class_simulation.html#afb2cf4feeb4d8292eeba8f9ef393c6a4", null ],
     [ "Logfile", "class_simulation.html#a741321a0bbc89d51b969abda469e6f96", null ]
 ];
\ No newline at end of file
diff --git a/docs/functions.html b/docs/functions.html
index d5f9987..b7dd701 100644
--- a/docs/functions.html
+++ b/docs/functions.html
@@ -130,10 +130,16 @@ <h3><a id="index_c"></a>- c -</h3><ul>
 <li>chooseNextEvent()
 : <a class="el" href="class_simulation.html#af8cf2e5c24531582599423df2d70dc5b">Simulation</a>
 </li>
+<li>chooseRandomUnoccupiedNeighbor()
+: <a class="el" href="class_lattice.html#abf954e8213010ab8aeac7a0b93a869bc">Lattice</a>
+</li>
 <li>clearOccupancy()
 : <a class="el" href="class_lattice.html#a97a1b4f24cd40b81ed63aa2d7713b63b">Lattice</a>
 , <a class="el" href="class_site.html#a46ff077954e39046b493ee1ea57a9c93">Site</a>
 </li>
+<li>Coords()
+: <a class="el" href="struct_coords.html#a246211bba85765d5d67953922070d11f">Coords</a>
+</li>
 </ul>
 
 
@@ -198,7 +204,7 @@ <h3><a id="index_g"></a>- g -</h3><ul>
 : <a class="el" href="class_lattice.html#a96006397a6ab389fb1eee87fde6e2165">Lattice</a>
 </li>
 <li>generator
-: <a class="el" href="class_simulation.html#a4c1d9071749e0fd93e70380cafb28417">Simulation</a>
+: <a class="el" href="class_simulation.html#a269659fa336a5563e2ccfe2db1654ba9">Simulation</a>
 </li>
 <li>getAllEventPtrs()
 : <a class="el" href="class_simulation.html#aec6a6e1a80eb566685e4d257e6f872c5">Simulation</a>
@@ -242,6 +248,9 @@ <h3><a id="index_g"></a>- g -</h3><ul>
 <li>getN_events_executed()
 : <a class="el" href="class_simulation.html#a52cb5564151421cbefaca56357738de7">Simulation</a>
 </li>
+<li>getN_objects_created()
+: <a class="el" href="class_simulation.html#ab07386326b1844df84464abe30927bf5">Simulation</a>
+</li>
 <li>getNumSites()
 : <a class="el" href="class_lattice.html#a4be17e9123f7737387991a9d1a8b87b3">Lattice</a>
 </li>
@@ -305,7 +314,7 @@ <h3><a id="index_i"></a>- i -</h3><ul>
 : <a class="el" href="class_object.html#a440b267c478f5d63db1954bdbd543408">Object</a>
 </li>
 <li>init()
-: <a class="el" href="class_lattice.html#a2b0a88048fae662aa71386a3a123a260">Lattice</a>
+: <a class="el" href="class_lattice.html#ab7322e5340badb9df4d208554fd90a89">Lattice</a>
 , <a class="el" href="class_simulation.html#af88e5e0634b373ba28f1dd87670725a6">Simulation</a>
 </li>
 <li>isLoggingEnabled()
diff --git a/docs/functions_func.html b/docs/functions_func.html
index 2b09ff5..df6b63f 100644
--- a/docs/functions_func.html
+++ b/docs/functions_func.html
@@ -130,10 +130,16 @@ <h3><a id="index_c"></a>- c -</h3><ul>
 <li>chooseNextEvent()
 : <a class="el" href="class_simulation.html#af8cf2e5c24531582599423df2d70dc5b">Simulation</a>
 </li>
+<li>chooseRandomUnoccupiedNeighbor()
+: <a class="el" href="class_lattice.html#abf954e8213010ab8aeac7a0b93a869bc">Lattice</a>
+</li>
 <li>clearOccupancy()
 : <a class="el" href="class_lattice.html#a97a1b4f24cd40b81ed63aa2d7713b63b">Lattice</a>
 , <a class="el" href="class_site.html#a46ff077954e39046b493ee1ea57a9c93">Site</a>
 </li>
+<li>Coords()
+: <a class="el" href="struct_coords.html#a5922d1783cefa759950faa50ac347191">Coords</a>
+</li>
 </ul>
 
 
@@ -209,6 +215,9 @@ <h3><a id="index_g"></a>- g -</h3><ul>
 <li>getN_events_executed()
 : <a class="el" href="class_simulation.html#a52cb5564151421cbefaca56357738de7">Simulation</a>
 </li>
+<li>getN_objects_created()
+: <a class="el" href="class_simulation.html#ab07386326b1844df84464abe30927bf5">Simulation</a>
+</li>
 <li>getNumSites()
 : <a class="el" href="class_lattice.html#a4be17e9123f7737387991a9d1a8b87b3">Lattice</a>
 </li>
@@ -264,7 +273,7 @@ <h3><a id="index_i"></a>- i -</h3><ul>
 : <a class="el" href="class_object.html#a440b267c478f5d63db1954bdbd543408">Object</a>
 </li>
 <li>init()
-: <a class="el" href="class_lattice.html#a2b0a88048fae662aa71386a3a123a260">Lattice</a>
+: <a class="el" href="class_lattice.html#ab7322e5340badb9df4d208554fd90a89">Lattice</a>
 , <a class="el" href="class_simulation.html#af88e5e0634b373ba28f1dd87670725a6">Simulation</a>
 </li>
 <li>isLoggingEnabled()
diff --git a/docs/functions_vars.html b/docs/functions_vars.html
index 6d5597a..bf62253 100644
--- a/docs/functions_vars.html
+++ b/docs/functions_vars.html
@@ -119,7 +119,7 @@
 : <a class="el" href="class_simulation.html#a954f41f4332dabda0fecea5d72151988">Simulation</a>
 </li>
 <li>generator
-: <a class="el" href="class_simulation.html#a4c1d9071749e0fd93e70380cafb28417">Simulation</a>
+: <a class="el" href="class_simulation.html#a269659fa336a5563e2ccfe2db1654ba9">Simulation</a>
 </li>
 <li>Height
 : <a class="el" href="struct_parameters___lattice.html#a1b59e1a307ad945fb86f44b68354f605">Parameters_Lattice</a>
diff --git a/docs/index.html b/docs/index.html
index 6a9222d..a15b8e4 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -92,11 +92,43 @@
 </div><!--header-->
 <div class="contents">
 <div class="textblock"><h2>General Information</h2>
-<p>This object-oriented C++ software package contains a general framework for lattice kinetic Monte Carlo (KMC) simulations. This framework consists of a number of utility functions and base classes that must be extended to create a fully operational KMC simulation. The goal of this package is to be robust and flexible so that users can easily develop KMC simulations for a wide variety of different scientific problems without the need to start from scratch.</p>
-<p>This KMC_Lattice package implements several event recalculation options for creating computationally efficient simulations. The package is designed to be usable on a personal computer and on high performance computing clusters. A simple example implementation of this general KMC framework can be found in the <a href="https://github.com/MikeHeiber/KMC_Lattice_example">KMC_Lattice_example</a> package. To see a more complete implementation for simulating a complex system, check out the <a href="https://github.com/MikeHeiber/Excimontec">Excimontec</a> software package that is used for simulating organic semiconductor materials and devices.</p>
+<p>This object-oriented C++ software package contains a general framework for lattice kinetic Monte Carlo (KMC) simulations. This framework consists of a number of utility functions and base classes that must be extended to create a fully operational KMC simulation. The goal of this package is to be robust, reliable, and flexible so that users can easily develop KMC simulations for a wide variety of different scientific problems without the need to start from scratch.</p>
+<p>This KMC_Lattice package implements several event recalculation options for creating computationally efficient simulations. The package is designed to be usable on a personal computer and on high performance computing clusters. Check out the <a href="https://github.com/MikeHeiber/Excimontec">Excimontec</a> software package for an example of a complex tool constructed using KMC_Lattice, which is used for simulating organic semiconductor materials and devices.</p>
 <p>For further reading about kinetic Monte Carlo simulations, a nice overview of the theory and algorithm can be found here:</p>
 <p><a href="http://www.fml.t.u-tokyo.ac.jp/~izumi/CMS/MC/Introduction_kMC.pdf">Introduction to the Kinetic Monte Carlo Method by Arthur Voter, Los Alamos National Lab</a></p>
-<h2>Work Together</h2>
+<h2>Current Status</h2>
+<p>The current release is KMC_Lattice <a href="https://github.com/MikeHeiber/KMC_Lattice/releases"></a> Most major planned features that are to be included in v2.0 are now implemented and have undergone preliminary testing. However, this software tool is still under development, and as such, there may still be bugs that need to be squashed. Please report any bugs or submit feature requests in the <a href="https://github.com/MikeHeiber/KMC_Lattice/issues">Issues</a> section.</p>
+<h4>Continuous Integration and Testing Status:</h4>
+<p>KMC_Lattice is currently being tested on <a href="https://www.ubuntu.com/">Ubuntu</a> v14.04 with the <a href="https://gcc.gnu.org/">GCC compiler</a> (versions 4.7, 4.8, 4.9, 5, 6, 7, and 8) and on both <a href="http://www.open-mpi.org/">Open MPI</a> v1.6.5 and <a href="http://www.mpich.org/">MPICH</a> v3.04 using <a href="https://travis-ci.com/">Travis CI</a>.</p>
+<table class="markdownTable">
+<tr class="markdownTableHead">
+<th class="markdownTableHeadCenter">Branch  </th><th class="markdownTableHeadNone">Status   </th></tr>
+<tr class="markdownTableBody" class="markdownTableRowOdd">
+<td class="markdownTableBodyCenter">Master  </td><td class="markdownTableBodyNone"><a href="https://travis-ci.org/MikeHeiber/KMC_Lattice"></a>   </td></tr>
+<tr class="markdownTableBody" class="markdownTableRowEven">
+<td class="markdownTableBodyCenter">Development  </td><td class="markdownTableBodyNone"><a href="https://travis-ci.org/MikeHeiber/KMC_Lattice"></a>   </td></tr>
+</table>
+<p>Code is being tested using <a href="https://github.com/google/googletest">googletest</a> with test coverage assessment by <a href="https://coveralls.io/">Coveralls</a>.</p>
+<table class="markdownTable">
+<tr class="markdownTableHead">
+<th class="markdownTableHeadCenter">Branch  </th><th class="markdownTableHeadNone">Status   </th></tr>
+<tr class="markdownTableBody" class="markdownTableRowOdd">
+<td class="markdownTableBodyCenter">Master  </td><td class="markdownTableBodyNone"><a href="https://coveralls.io/github/MikeHeiber/KMC_Lattice?branch=master"></a>   </td></tr>
+<tr class="markdownTableBody" class="markdownTableRowEven">
+<td class="markdownTableBodyCenter">Development  </td><td class="markdownTableBodyNone"><a href="https://coveralls.io/github/MikeHeiber/KMC_Lattice?branch=development"></a>   </td></tr>
+</table>
+<h2>Contact</h2>
+<p>If you would like to contribute to the development of this project or would like some help in using the tool for your research, please contact me (<a href="#" onclick="location.href='mai'+'lto:'+'hei'+'be'+'r@m'+'ai'+'lap'+'s.'+'org'; return false;">heibe<span style="display: none;">.nosp@m.</span>r@ma<span style="display: none;">.nosp@m.</span>ilaps<span style="display: none;">.nosp@m.</span>.org</a>) to discuss a collaboration. You can check out my KMC research and other work on <a href="https://www.researchgate.net/profile/Michael_Heiber">Researchgate</a>.</p>
+<h2>How to try KMC_Lattice?</h2>
+<h4>Building and Testing the KMC_Lattice Library</h4>
+<p>This software tool uses <a href="https://computing.llnl.gov/tutorials/mpi/">Message Passing Interface (MPI)</a> to utilize parallel computing power. As a result, using KMC_Lattice requires that an MPI library is pre-installed on your system, and the final KMC_Lattice library must be built on your specific system. We cannot provide pre-built binaries for your system. Contact your HPC admin to determine the protocols for building MPI applications on your HPC system. In many cases, the HPC system will already be configured for you, and the package comes with a default makefile that can be used with the <a href="https://gcc.gnu.org/">GCC compiler</a> or the <a href="https://www.pgroup.com/">PGI compiler</a>.</p>
+<p>If you wish, you can also install MPI on your own personal workstation and then build the KMC_Lattice library there as well. For development and preliminary simulation tests, sometimes it is more efficient to run on your own workstation instead of an HPC system. More information about common MPI packages can be found here:</p><ul>
+<li>Open MPI, <a href="http://www.open-mpi.org/">http://www.open-mpi.org/</a></li>
+<li>MPICH, <a href="http://www.mpich.org/">http://www.mpich.org/</a></li>
+<li>MVAPICH, <a href="http://mvapich.cse.ohio-state.edu/">http://mvapich.cse.ohio-state.edu/</a></li>
+</ul>
+<p>Once you have an MPI library installed, to build the KMC_Lattice library, copy the KMC_Lattice directory to your machine, set it as your working directory, and run <code>make</code>. Compilation flags have been set for GCC and PGI compilers. If you are using another compiler, you will need to edit the makefile and define your own compiler options. However, before you use the KMC_Lattice library, you should test it on your own hardware using the unit and system tests provided. Build the testing executable by running <code>make test</code>. Once the test build is complete, run <code>./test/KMC_Lattice_tests.exe</code>. Please report any build or testing errors in the <a href="https://github.com/MikeHeiber/KMC_Lattice/issues">Issues</a> section.</p>
+<h2>Contact</h2>
 <p>If you would like to contribute to the development of this project or would like some help in building an efficient KMC simulation tool for your specific scientific problem, please contact me to discuss a collaboration. You can check out my KMC research and other work on <a href="https://www.researchgate.net/profile/Michael_Heiber">Researchgate</a>.</p>
 <h2>Package Contents</h2>
 <p><a class="el" href="class_object.html" title="This base class contains the basic properties of a KMC simulation object and the functions needed to ...">Object</a> class - This base class can be extended to represent any entity that one would like to simulate. It could represent an electron, atom, molecule, organism, etc. depending on the application. The <a class="el" href="class_object.html" title="This base class contains the basic properties of a KMC simulation object and the functions needed to ...">Object</a> class contains the fundamental properties and back-end operations that any given entity simulation would require.</p>
diff --git a/docs/md__r_e_a_d_m_e.html b/docs/md__r_e_a_d_m_e.html
index 6a9222d..a15b8e4 100644
--- a/docs/md__r_e_a_d_m_e.html
+++ b/docs/md__r_e_a_d_m_e.html
@@ -92,11 +92,43 @@
 </div><!--header-->
 <div class="contents">
 <div class="textblock"><h2>General Information</h2>
-<p>This object-oriented C++ software package contains a general framework for lattice kinetic Monte Carlo (KMC) simulations. This framework consists of a number of utility functions and base classes that must be extended to create a fully operational KMC simulation. The goal of this package is to be robust and flexible so that users can easily develop KMC simulations for a wide variety of different scientific problems without the need to start from scratch.</p>
-<p>This KMC_Lattice package implements several event recalculation options for creating computationally efficient simulations. The package is designed to be usable on a personal computer and on high performance computing clusters. A simple example implementation of this general KMC framework can be found in the <a href="https://github.com/MikeHeiber/KMC_Lattice_example">KMC_Lattice_example</a> package. To see a more complete implementation for simulating a complex system, check out the <a href="https://github.com/MikeHeiber/Excimontec">Excimontec</a> software package that is used for simulating organic semiconductor materials and devices.</p>
+<p>This object-oriented C++ software package contains a general framework for lattice kinetic Monte Carlo (KMC) simulations. This framework consists of a number of utility functions and base classes that must be extended to create a fully operational KMC simulation. The goal of this package is to be robust, reliable, and flexible so that users can easily develop KMC simulations for a wide variety of different scientific problems without the need to start from scratch.</p>
+<p>This KMC_Lattice package implements several event recalculation options for creating computationally efficient simulations. The package is designed to be usable on a personal computer and on high performance computing clusters. Check out the <a href="https://github.com/MikeHeiber/Excimontec">Excimontec</a> software package for an example of a complex tool constructed using KMC_Lattice, which is used for simulating organic semiconductor materials and devices.</p>
 <p>For further reading about kinetic Monte Carlo simulations, a nice overview of the theory and algorithm can be found here:</p>
 <p><a href="http://www.fml.t.u-tokyo.ac.jp/~izumi/CMS/MC/Introduction_kMC.pdf">Introduction to the Kinetic Monte Carlo Method by Arthur Voter, Los Alamos National Lab</a></p>
-<h2>Work Together</h2>
+<h2>Current Status</h2>
+<p>The current release is KMC_Lattice <a href="https://github.com/MikeHeiber/KMC_Lattice/releases"></a> Most major planned features that are to be included in v2.0 are now implemented and have undergone preliminary testing. However, this software tool is still under development, and as such, there may still be bugs that need to be squashed. Please report any bugs or submit feature requests in the <a href="https://github.com/MikeHeiber/KMC_Lattice/issues">Issues</a> section.</p>
+<h4>Continuous Integration and Testing Status:</h4>
+<p>KMC_Lattice is currently being tested on <a href="https://www.ubuntu.com/">Ubuntu</a> v14.04 with the <a href="https://gcc.gnu.org/">GCC compiler</a> (versions 4.7, 4.8, 4.9, 5, 6, 7, and 8) and on both <a href="http://www.open-mpi.org/">Open MPI</a> v1.6.5 and <a href="http://www.mpich.org/">MPICH</a> v3.04 using <a href="https://travis-ci.com/">Travis CI</a>.</p>
+<table class="markdownTable">
+<tr class="markdownTableHead">
+<th class="markdownTableHeadCenter">Branch  </th><th class="markdownTableHeadNone">Status   </th></tr>
+<tr class="markdownTableBody" class="markdownTableRowOdd">
+<td class="markdownTableBodyCenter">Master  </td><td class="markdownTableBodyNone"><a href="https://travis-ci.org/MikeHeiber/KMC_Lattice"></a>   </td></tr>
+<tr class="markdownTableBody" class="markdownTableRowEven">
+<td class="markdownTableBodyCenter">Development  </td><td class="markdownTableBodyNone"><a href="https://travis-ci.org/MikeHeiber/KMC_Lattice"></a>   </td></tr>
+</table>
+<p>Code is being tested using <a href="https://github.com/google/googletest">googletest</a> with test coverage assessment by <a href="https://coveralls.io/">Coveralls</a>.</p>
+<table class="markdownTable">
+<tr class="markdownTableHead">
+<th class="markdownTableHeadCenter">Branch  </th><th class="markdownTableHeadNone">Status   </th></tr>
+<tr class="markdownTableBody" class="markdownTableRowOdd">
+<td class="markdownTableBodyCenter">Master  </td><td class="markdownTableBodyNone"><a href="https://coveralls.io/github/MikeHeiber/KMC_Lattice?branch=master"></a>   </td></tr>
+<tr class="markdownTableBody" class="markdownTableRowEven">
+<td class="markdownTableBodyCenter">Development  </td><td class="markdownTableBodyNone"><a href="https://coveralls.io/github/MikeHeiber/KMC_Lattice?branch=development"></a>   </td></tr>
+</table>
+<h2>Contact</h2>
+<p>If you would like to contribute to the development of this project or would like some help in using the tool for your research, please contact me (<a href="#" onclick="location.href='mai'+'lto:'+'hei'+'be'+'r@m'+'ai'+'lap'+'s.'+'org'; return false;">heibe<span style="display: none;">.nosp@m.</span>r@ma<span style="display: none;">.nosp@m.</span>ilaps<span style="display: none;">.nosp@m.</span>.org</a>) to discuss a collaboration. You can check out my KMC research and other work on <a href="https://www.researchgate.net/profile/Michael_Heiber">Researchgate</a>.</p>
+<h2>How to try KMC_Lattice?</h2>
+<h4>Building and Testing the KMC_Lattice Library</h4>
+<p>This software tool uses <a href="https://computing.llnl.gov/tutorials/mpi/">Message Passing Interface (MPI)</a> to utilize parallel computing power. As a result, using KMC_Lattice requires that an MPI library is pre-installed on your system, and the final KMC_Lattice library must be built on your specific system. We cannot provide pre-built binaries for your system. Contact your HPC admin to determine the protocols for building MPI applications on your HPC system. In many cases, the HPC system will already be configured for you, and the package comes with a default makefile that can be used with the <a href="https://gcc.gnu.org/">GCC compiler</a> or the <a href="https://www.pgroup.com/">PGI compiler</a>.</p>
+<p>If you wish, you can also install MPI on your own personal workstation and then build the KMC_Lattice library there as well. For development and preliminary simulation tests, sometimes it is more efficient to run on your own workstation instead of an HPC system. More information about common MPI packages can be found here:</p><ul>
+<li>Open MPI, <a href="http://www.open-mpi.org/">http://www.open-mpi.org/</a></li>
+<li>MPICH, <a href="http://www.mpich.org/">http://www.mpich.org/</a></li>
+<li>MVAPICH, <a href="http://mvapich.cse.ohio-state.edu/">http://mvapich.cse.ohio-state.edu/</a></li>
+</ul>
+<p>Once you have an MPI library installed, to build the KMC_Lattice library, copy the KMC_Lattice directory to your machine, set it as your working directory, and run <code>make</code>. Compilation flags have been set for GCC and PGI compilers. If you are using another compiler, you will need to edit the makefile and define your own compiler options. However, before you use the KMC_Lattice library, you should test it on your own hardware using the unit and system tests provided. Build the testing executable by running <code>make test</code>. Once the test build is complete, run <code>./test/KMC_Lattice_tests.exe</code>. Please report any build or testing errors in the <a href="https://github.com/MikeHeiber/KMC_Lattice/issues">Issues</a> section.</p>
+<h2>Contact</h2>
 <p>If you would like to contribute to the development of this project or would like some help in building an efficient KMC simulation tool for your specific scientific problem, please contact me to discuss a collaboration. You can check out my KMC research and other work on <a href="https://www.researchgate.net/profile/Michael_Heiber">Researchgate</a>.</p>
 <h2>Package Contents</h2>
 <p><a class="el" href="class_object.html" title="This base class contains the basic properties of a KMC simulation object and the functions needed to ...">Object</a> class - This base class can be extended to represent any entity that one would like to simulate. It could represent an electron, atom, molecule, organism, etc. depending on the application. The <a class="el" href="class_object.html" title="This base class contains the basic properties of a KMC simulation object and the functions needed to ...">Object</a> class contains the fundamental properties and back-end operations that any given entity simulation would require.</p>
diff --git a/docs/namespace_utils.html b/docs/namespace_utils.html
index 43cd7ab..452cc20 100644
--- a/docs/namespace_utils.html
+++ b/docs/namespace_utils.html
@@ -108,12 +108,12 @@
 <tr class="memitem:a08553f36886a36456e8111585029e467"><td class="memItemLeft" align="right" valign="top">std::vector&lt; std::pair&lt; double, double &gt; &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespace_utils.html#a08553f36886a36456e8111585029e467">calculateProbabilityHist</a> (const std::vector&lt; double &gt; &amp;data, const double bin_size, const int num_bins)</td></tr>
 <tr class="memdesc:a08553f36886a36456e8111585029e467"><td class="mdescLeft">&#160;</td><td class="mdescRight">Calculates the probability histogram for the input data vector using the input bin size and input number of bins.  <a href="#a08553f36886a36456e8111585029e467">More...</a><br /></td></tr>
 <tr class="separator:a08553f36886a36456e8111585029e467"><td class="memSeparator" colspan="2">&#160;</td></tr>
-<tr class="memitem:af296d2aa8f889f67fe515fc641c5f5fe"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespace_utils.html#af296d2aa8f889f67fe515fc641c5f5fe">createExponentialDOSVector</a> (std::vector&lt; double &gt; &amp;data, const double mode, const double urbach_energy, std::mt19937 &amp;gen)</td></tr>
-<tr class="memdesc:af296d2aa8f889f67fe515fc641c5f5fe"><td class="mdescLeft">&#160;</td><td class="mdescRight">Creates a vector of doubles that has a custom asymmetric distribution with an exponential tail.  <a href="#af296d2aa8f889f67fe515fc641c5f5fe">More...</a><br /></td></tr>
-<tr class="separator:af296d2aa8f889f67fe515fc641c5f5fe"><td class="memSeparator" colspan="2">&#160;</td></tr>
-<tr class="memitem:a2ce45ade7d6d4f2995b595da3ebbaaec"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespace_utils.html#a2ce45ade7d6d4f2995b595da3ebbaaec">createGaussianDOSVector</a> (std::vector&lt; double &gt; &amp;data, const double mean, const double stdev, std::mt19937 &amp;gen)</td></tr>
-<tr class="memdesc:a2ce45ade7d6d4f2995b595da3ebbaaec"><td class="mdescLeft">&#160;</td><td class="mdescRight">Creates a vector of doubles that has a Gaussian distribution.  <a href="#a2ce45ade7d6d4f2995b595da3ebbaaec">More...</a><br /></td></tr>
-<tr class="separator:a2ce45ade7d6d4f2995b595da3ebbaaec"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a62ed21bf039a062d34511cd016cd9b59"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespace_utils.html#a62ed21bf039a062d34511cd016cd9b59">createExponentialDOSVector</a> (std::vector&lt; double &gt; &amp;data, const double mode, const double urbach_energy, std::mt19937_64 &amp;gen)</td></tr>
+<tr class="memdesc:a62ed21bf039a062d34511cd016cd9b59"><td class="mdescLeft">&#160;</td><td class="mdescRight">Creates a vector of doubles that has a custom asymmetric distribution with an exponential tail.  <a href="#a62ed21bf039a062d34511cd016cd9b59">More...</a><br /></td></tr>
+<tr class="separator:a62ed21bf039a062d34511cd016cd9b59"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:aa92dbcc79f8336fcd2d9644db1a2b0ae"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespace_utils.html#aa92dbcc79f8336fcd2d9644db1a2b0ae">createGaussianDOSVector</a> (std::vector&lt; double &gt; &amp;data, const double mean, const double stdev, std::mt19937_64 &amp;gen)</td></tr>
+<tr class="memdesc:aa92dbcc79f8336fcd2d9644db1a2b0ae"><td class="mdescLeft">&#160;</td><td class="mdescRight">Creates a vector of doubles that has a Gaussian distribution.  <a href="#aa92dbcc79f8336fcd2d9644db1a2b0ae">More...</a><br /></td></tr>
+<tr class="separator:aa92dbcc79f8336fcd2d9644db1a2b0ae"><td class="memSeparator" colspan="2">&#160;</td></tr>
 <tr class="memitem:a98a0cc670327fc21e272a07cbf5025ec"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespace_utils.html#a98a0cc670327fc21e272a07cbf5025ec">importBooleanParam</a> (const std::string &amp;input, bool &amp;error_status)</td></tr>
 <tr class="memdesc:a98a0cc670327fc21e272a07cbf5025ec"><td class="mdescLeft">&#160;</td><td class="mdescRight">Extracts a boolean value from a string containing "true" or "false".  <a href="#a98a0cc670327fc21e272a07cbf5025ec">More...</a><br /></td></tr>
 <tr class="separator:a98a0cc670327fc21e272a07cbf5025ec"><td class="memSeparator" colspan="2">&#160;</td></tr>
@@ -381,8 +381,8 @@ <h2 class="memtitle"><span class="permalink"><a href="#a08553f36886a36456e811158
 
 </div>
 </div>
-<a id="af296d2aa8f889f67fe515fc641c5f5fe"></a>
-<h2 class="memtitle"><span class="permalink"><a href="#af296d2aa8f889f67fe515fc641c5f5fe">&#9670;&nbsp;</a></span>createExponentialDOSVector()</h2>
+<a id="a62ed21bf039a062d34511cd016cd9b59"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a62ed21bf039a062d34511cd016cd9b59">&#9670;&nbsp;</a></span>createExponentialDOSVector()</h2>
 
 <div class="memitem">
 <div class="memproto">
@@ -408,7 +408,7 @@ <h2 class="memtitle"><span class="permalink"><a href="#af296d2aa8f889f67fe515fc6
         <tr>
           <td class="paramkey"></td>
           <td></td>
-          <td class="paramtype">std::mt19937 &amp;&#160;</td>
+          <td class="paramtype">std::mt19937_64 &amp;&#160;</td>
           <td class="paramname"><em>gen</em>&#160;</td>
         </tr>
         <tr>
@@ -432,8 +432,8 @@ <h2 class="memtitle"><span class="permalink"><a href="#af296d2aa8f889f67fe515fc6
 
 </div>
 </div>
-<a id="a2ce45ade7d6d4f2995b595da3ebbaaec"></a>
-<h2 class="memtitle"><span class="permalink"><a href="#a2ce45ade7d6d4f2995b595da3ebbaaec">&#9670;&nbsp;</a></span>createGaussianDOSVector()</h2>
+<a id="aa92dbcc79f8336fcd2d9644db1a2b0ae"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa92dbcc79f8336fcd2d9644db1a2b0ae">&#9670;&nbsp;</a></span>createGaussianDOSVector()</h2>
 
 <div class="memitem">
 <div class="memproto">
@@ -459,7 +459,7 @@ <h2 class="memtitle"><span class="permalink"><a href="#a2ce45ade7d6d4f2995b595da
         <tr>
           <td class="paramkey"></td>
           <td></td>
-          <td class="paramtype">std::mt19937 &amp;&#160;</td>
+          <td class="paramtype">std::mt19937_64 &amp;&#160;</td>
           <td class="paramname"><em>gen</em>&#160;</td>
         </tr>
         <tr>
@@ -734,7 +734,7 @@ <h2 class="memtitle"><span class="permalink"><a href="#aee439dad386e2477d3496831
 </div><div class="memdoc">
 
 <p>Uses MPI to gather vectors from separate processors to build one big vector containing all of the data. </p>
-<p>Each processor calls this function and sends an input vector. Upon function return, processor 0 receives the large data vector and all of the othe rprocessors receive an empty vector. </p><dl class="params"><dt>Parameters</dt><dd>
+<p>Each processor calls this function and sends an input vector. Upon function return, processor 0 receives the large data vector and all of the other processors receive an empty vector. </p><dl class="params"><dt>Parameters</dt><dd>
   <table class="params">
     <tr><td class="paramname">input_vector</td><td>is the input data from the processor calling the function. </td></tr>
   </table>
@@ -763,7 +763,7 @@ <h2 class="memtitle"><span class="permalink"><a href="#ad44ab8e489dbb7e24480f4e0
 </div><div class="memdoc">
 
 <p>Uses MPI to gather vectors from separate processors to build one big vector containing all of the data. </p>
-<p>Each processor calls this function and sends an input vector. Upon function return, processor 0 receives the large data vector and all of the othe rprocessors receive an empty vector. </p><dl class="params"><dt>Parameters</dt><dd>
+<p>Each processor calls this function and sends an input vector. Upon function return, processor 0 receives the large data vector and all of the other processors receive an empty vector. </p><dl class="params"><dt>Parameters</dt><dd>
   <table class="params">
     <tr><td class="paramname">input_vector</td><td>is the input data from the processor calling the function. </td></tr>
   </table>
@@ -874,7 +874,7 @@ <h2 class="memtitle"><span class="permalink"><a href="#a5f64d00eec0b50ac5bd11965
 </div><div class="memdoc">
 
 <p>This template function efficienctly removes the duplicate entries from an input vector. </p>
-<p>This algorithm allow efficient removal of duplicate vector objects when &gt; or &lt; comparison operators do not exist. </p><dl class="params"><dt>Parameters</dt><dd>
+<p>This algorithm allows efficient removal of duplicate vector objects when &gt; or &lt; comparison operators do not exist. </p><dl class="params"><dt>Parameters</dt><dd>
   <table class="params">
     <tr><td class="paramname">vec</td><td>is the input vector to be operated on. </td></tr>
   </table>
diff --git a/docs/namespacemembers.html b/docs/namespacemembers.html
index c77c7d2..72f3364 100644
--- a/docs/namespacemembers.html
+++ b/docs/namespacemembers.html
@@ -98,10 +98,10 @@
 : <a class="el" href="namespace_utils.html#adcb2e98774b12bc12264034913547a2c">Utils</a>
 </li>
 <li>createExponentialDOSVector()
-: <a class="el" href="namespace_utils.html#af296d2aa8f889f67fe515fc641c5f5fe">Utils</a>
+: <a class="el" href="namespace_utils.html#a62ed21bf039a062d34511cd016cd9b59">Utils</a>
 </li>
 <li>createGaussianDOSVector()
-: <a class="el" href="namespace_utils.html#a2ce45ade7d6d4f2995b595da3ebbaaec">Utils</a>
+: <a class="el" href="namespace_utils.html#aa92dbcc79f8336fcd2d9644db1a2b0ae">Utils</a>
 </li>
 <li>importBooleanParam()
 : <a class="el" href="namespace_utils.html#a98a0cc670327fc21e272a07cbf5025ec">Utils</a>
diff --git a/docs/namespacemembers_func.html b/docs/namespacemembers_func.html
index cf88be9..c752fa5 100644
--- a/docs/namespacemembers_func.html
+++ b/docs/namespacemembers_func.html
@@ -98,10 +98,10 @@
 : <a class="el" href="namespace_utils.html#adcb2e98774b12bc12264034913547a2c">Utils</a>
 </li>
 <li>createExponentialDOSVector()
-: <a class="el" href="namespace_utils.html#af296d2aa8f889f67fe515fc641c5f5fe">Utils</a>
+: <a class="el" href="namespace_utils.html#a62ed21bf039a062d34511cd016cd9b59">Utils</a>
 </li>
 <li>createGaussianDOSVector()
-: <a class="el" href="namespace_utils.html#a2ce45ade7d6d4f2995b595da3ebbaaec">Utils</a>
+: <a class="el" href="namespace_utils.html#aa92dbcc79f8336fcd2d9644db1a2b0ae">Utils</a>
 </li>
 <li>importBooleanParam()
 : <a class="el" href="namespace_utils.html#a98a0cc670327fc21e272a07cbf5025ec">Utils</a>
diff --git a/docs/navtreeindex0.js b/docs/navtreeindex0.js
index be68629..d64874b 100644
--- a/docs/navtreeindex0.js
+++ b/docs/navtreeindex0.js
@@ -24,37 +24,38 @@ var NAVTREEINDEX0 =
 "class_event.html#af4282af20bd5b3940ba75c23e6032f18":[2,0,1,10],
 "class_lattice.html":[2,0,2],
 "class_lattice.html#a08adb2f412af409d3ec241e60e687c1a":[2,0,2,2],
-"class_lattice.html#a180a9d79a40b1a0a092c8ab489569700":[2,0,2,13],
-"class_lattice.html#a2b0a88048fae662aa71386a3a123a260":[2,0,2,24],
+"class_lattice.html#a180a9d79a40b1a0a092c8ab489569700":[2,0,2,14],
 "class_lattice.html#a3f51b0b41cf0e43e0469320310494a1e":[2,0,2,8],
-"class_lattice.html#a46f7d12855d24e1bdd02814621b0a178":[2,0,2,20],
-"class_lattice.html#a46f9cec33419459b64ff0efdf47a38b9":[2,0,2,22],
-"class_lattice.html#a4b43b67a36fcd3dfe62c9eeaffa561d2":[2,0,2,16],
-"class_lattice.html#a4be17e9123f7737387991a9d1a8b87b3":[2,0,2,17],
-"class_lattice.html#a4d37afb6ad4c67f4f6462c2f6d5c337d":[2,0,2,25],
+"class_lattice.html#a46f7d12855d24e1bdd02814621b0a178":[2,0,2,21],
+"class_lattice.html#a46f9cec33419459b64ff0efdf47a38b9":[2,0,2,23],
+"class_lattice.html#a4b43b67a36fcd3dfe62c9eeaffa561d2":[2,0,2,17],
+"class_lattice.html#a4be17e9123f7737387991a9d1a8b87b3":[2,0,2,18],
+"class_lattice.html#a4d37afb6ad4c67f4f6462c2f6d5c337d":[2,0,2,26],
 "class_lattice.html#a4e8b3577701ec0cefce595f6956b22e3":[2,0,2,5],
-"class_lattice.html#a515b8bc548ef4a87c3495a7352a60399":[2,0,2,30],
+"class_lattice.html#a515b8bc548ef4a87c3495a7352a60399":[2,0,2,31],
 "class_lattice.html#a584ff9c528ebe46a6aea6ed652d107f4":[2,0,2,6],
-"class_lattice.html#a59546ec4301871897ba5adfda1126741":[2,0,2,31],
-"class_lattice.html#a60431f6504a253d47acb0b02f524571c":[2,0,2,19],
+"class_lattice.html#a59546ec4301871897ba5adfda1126741":[2,0,2,32],
+"class_lattice.html#a60431f6504a253d47acb0b02f524571c":[2,0,2,20],
 "class_lattice.html#a70a5cebc3c0c5a0f609be0592e7cc117":[2,0,2,0],
-"class_lattice.html#a74a170b841ad1b74dad43519d37e9eaf":[2,0,2,18],
+"class_lattice.html#a74a170b841ad1b74dad43519d37e9eaf":[2,0,2,19],
 "class_lattice.html#a76b38079e102e17c79b13a3398a404a0":[2,0,2,7],
-"class_lattice.html#a96006397a6ab389fb1eee87fde6e2165":[2,0,2,14],
-"class_lattice.html#a97a1b4f24cd40b81ed63aa2d7713b63b":[2,0,2,10],
-"class_lattice.html#a9fbb3c8bc23999ff685b6837beb62606":[2,0,2,11],
-"class_lattice.html#aa1f65735ecbd750ec04b6413b4d47316":[2,0,2,29],
+"class_lattice.html#a96006397a6ab389fb1eee87fde6e2165":[2,0,2,15],
+"class_lattice.html#a97a1b4f24cd40b81ed63aa2d7713b63b":[2,0,2,11],
+"class_lattice.html#a9fbb3c8bc23999ff685b6837beb62606":[2,0,2,12],
+"class_lattice.html#aa1f65735ecbd750ec04b6413b4d47316":[2,0,2,30],
 "class_lattice.html#aa6b80d6264bfc23ae5fea39abd2557d5":[2,0,2,1],
-"class_lattice.html#aaa0cba3ab33ac620d9b9f9508c56d1ac":[2,0,2,15],
-"class_lattice.html#ab78435e50e3bf9f376c04fc305785bb4":[2,0,2,12],
-"class_lattice.html#ac3192acefb019c5258143a6c758b3e48":[2,0,2,27],
-"class_lattice.html#ac6963a6b2b4b8d96d3417f6e9c2a509d":[2,0,2,21],
-"class_lattice.html#accf3b995e0d0cb422907728a29b1b523":[2,0,2,26],
+"class_lattice.html#aaa0cba3ab33ac620d9b9f9508c56d1ac":[2,0,2,16],
+"class_lattice.html#ab7322e5340badb9df4d208554fd90a89":[2,0,2,25],
+"class_lattice.html#ab78435e50e3bf9f376c04fc305785bb4":[2,0,2,13],
+"class_lattice.html#abf954e8213010ab8aeac7a0b93a869bc":[2,0,2,10],
+"class_lattice.html#ac3192acefb019c5258143a6c758b3e48":[2,0,2,28],
+"class_lattice.html#ac6963a6b2b4b8d96d3417f6e9c2a509d":[2,0,2,22],
+"class_lattice.html#accf3b995e0d0cb422907728a29b1b523":[2,0,2,27],
 "class_lattice.html#acdeca889f7df11fe299f8b7941198c83":[2,0,2,4],
 "class_lattice.html#ad0592298c4b92e9e84a768b95cd6d0f0":[2,0,2,9],
-"class_lattice.html#ad7dd1b12a253e506aba5cedb57bf86ea":[2,0,2,28],
+"class_lattice.html#ad7dd1b12a253e506aba5cedb57bf86ea":[2,0,2,29],
 "class_lattice.html#ad89c5473dd37339ede9fb3d0c3db4300":[2,0,2,3],
-"class_lattice.html#aeb60d2b8bfb02d9da8bef463f0d41428":[2,0,2,23],
+"class_lattice.html#aeb60d2b8bfb02d9da8bef463f0d41428":[2,0,2,24],
 "class_object.html":[2,0,3],
 "class_object.html#a02643ea0804dec3e43f60c788855c03b":[2,0,3,3],
 "class_object.html#a08df08943dc634609fa69b356a37d73f":[2,0,3,4],
@@ -73,36 +74,37 @@ var NAVTREEINDEX0 =
 "class_object.html#aff050a622272cc7667251c7315f09fd7":[2,0,3,2],
 "class_simulation.html":[2,0,6],
 "class_simulation.html#a03d249f04c0921c938d68337dfc65f56":[2,0,6,10],
-"class_simulation.html#a0f06c75c9dd6be20a3911781b48fd467":[2,0,6,23],
-"class_simulation.html#a1a825b9da67da43104137662694655bd":[2,0,6,24],
+"class_simulation.html#a0f06c75c9dd6be20a3911781b48fd467":[2,0,6,24],
+"class_simulation.html#a1a825b9da67da43104137662694655bd":[2,0,6,25],
 "class_simulation.html#a1e0f43c4e11eda5486054c250f4de08f":[2,0,6,3],
+"class_simulation.html#a269659fa336a5563e2ccfe2db1654ba9":[2,0,6,30],
 "class_simulation.html#a33a57b5640b0d33c816dc6e57604162e":[2,0,6,2],
-"class_simulation.html#a391ac262089c8bda8e76ce930b1db88b":[2,0,6,15],
-"class_simulation.html#a39da17feb9b487c05c9a834def44972f":[2,0,6,22],
-"class_simulation.html#a3a4808231d4760f0ab30ea39b6a67e8c":[2,0,6,21],
-"class_simulation.html#a43ca861e2514feb7f93bf18ea3b73385":[2,0,6,25],
+"class_simulation.html#a391ac262089c8bda8e76ce930b1db88b":[2,0,6,16],
+"class_simulation.html#a39da17feb9b487c05c9a834def44972f":[2,0,6,23],
+"class_simulation.html#a3a4808231d4760f0ab30ea39b6a67e8c":[2,0,6,22],
+"class_simulation.html#a43ca861e2514feb7f93bf18ea3b73385":[2,0,6,26],
 "class_simulation.html#a48e9e82f9dac1acec5d063a9f6f6115e":[2,0,6,6],
-"class_simulation.html#a4c1d9071749e0fd93e70380cafb28417":[2,0,6,29],
 "class_simulation.html#a52cb5564151421cbefaca56357738de7":[2,0,6,13],
-"class_simulation.html#a59666ceba048bec35557cb8b691d24d9":[2,0,6,19],
+"class_simulation.html#a59666ceba048bec35557cb8b691d24d9":[2,0,6,20],
 "class_simulation.html#a5b224cc5b36bcc8eb29689aff223de41":[2,0,6,1],
 "class_simulation.html#a620684b9ac1fb07344c4c2237ed9f352":[2,0,6,9],
-"class_simulation.html#a623c3fbc431ab74c2d2b2374a3b5a3a7":[2,0,6,16],
+"class_simulation.html#a623c3fbc431ab74c2d2b2374a3b5a3a7":[2,0,6,17],
 "class_simulation.html#a662702acf2d446dbdef0e1c87bf21038":[2,0,6,7],
-"class_simulation.html#a741321a0bbc89d51b969abda469e6f96":[2,0,6,31],
+"class_simulation.html#a741321a0bbc89d51b969abda469e6f96":[2,0,6,32],
 "class_simulation.html#a7d88f18a1ba988d7e77b8be8de5b10d1":[2,0,6,12],
-"class_simulation.html#a7f4615a7898fb83d09be5e7fad92bb47":[2,0,6,27],
+"class_simulation.html#a7f4615a7898fb83d09be5e7fad92bb47":[2,0,6,28],
 "class_simulation.html#a80fad3f57dfaf195a36f7bc49bc88279":[2,0,6,0],
-"class_simulation.html#a938de951b2766c6fb2b00cf9714caffa":[2,0,6,20],
-"class_simulation.html#a954f41f4332dabda0fecea5d72151988":[2,0,6,28],
-"class_simulation.html#aae315f0881f0b385c566f96beb01d3f6":[2,0,6,26],
-"class_simulation.html#ac00bce7c792fb67a75395c46c03efe0a":[2,0,6,14],
-"class_simulation.html#ac7c8a49a4cc506b850891480e0aae512":[2,0,6,18],
+"class_simulation.html#a938de951b2766c6fb2b00cf9714caffa":[2,0,6,21],
+"class_simulation.html#a954f41f4332dabda0fecea5d72151988":[2,0,6,29],
+"class_simulation.html#aae315f0881f0b385c566f96beb01d3f6":[2,0,6,27],
+"class_simulation.html#ab07386326b1844df84464abe30927bf5":[2,0,6,14],
+"class_simulation.html#ac00bce7c792fb67a75395c46c03efe0a":[2,0,6,15],
+"class_simulation.html#ac7c8a49a4cc506b850891480e0aae512":[2,0,6,19],
 "class_simulation.html#aec6a6e1a80eb566685e4d257e6f872c5":[2,0,6,8],
 "class_simulation.html#af69bb46977a3a0084214a194c888e16c":[2,0,6,4],
-"class_simulation.html#af88e5e0634b373ba28f1dd87670725a6":[2,0,6,17],
+"class_simulation.html#af88e5e0634b373ba28f1dd87670725a6":[2,0,6,18],
 "class_simulation.html#af8cf2e5c24531582599423df2d70dc5b":[2,0,6,5],
-"class_simulation.html#afb2cf4feeb4d8292eeba8f9ef393c6a4":[2,0,6,30],
+"class_simulation.html#afb2cf4feeb4d8292eeba8f9ef393c6a4":[2,0,6,31],
 "class_simulation.html#aff40f268758bd9a0f390a649fc45c05e":[2,0,6,11],
 "class_site.html":[2,0,7],
 "class_site.html#a30991b768ded0bb441c5bb54a789160a":[2,0,7,4],
@@ -125,12 +127,14 @@ var NAVTREEINDEX0 =
 "namespaces.html":[1,0],
 "pages.html":[],
 "struct_coords.html":[2,0,0],
-"struct_coords.html#a59992d986e76375f31828d32c05cd15d":[2,0,0,3],
-"struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f":[2,0,0,4],
-"struct_coords.html#a88de3a6ee710766eb9c9444cee45a9f3":[2,0,0,2],
-"struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1":[2,0,0,5],
-"struct_coords.html#aaea2c566feec4e4bf56b27a34568be76":[2,0,0,0],
-"struct_coords.html#ad3347f6568814df1a2b98b3cd0b78632":[2,0,0,1],
+"struct_coords.html#a246211bba85765d5d67953922070d11f":[2,0,0,1],
+"struct_coords.html#a5922d1783cefa759950faa50ac347191":[2,0,0,0],
+"struct_coords.html#a59992d986e76375f31828d32c05cd15d":[2,0,0,5],
+"struct_coords.html#a7ed64d02fb7550f1506a93fcfab7f16f":[2,0,0,6],
+"struct_coords.html#a88de3a6ee710766eb9c9444cee45a9f3":[2,0,0,4],
+"struct_coords.html#a96d176173dbd5d97e7af63e1b5c0f7e1":[2,0,0,7],
+"struct_coords.html#aaea2c566feec4e4bf56b27a34568be76":[2,0,0,2],
+"struct_coords.html#ad3347f6568814df1a2b98b3cd0b78632":[2,0,0,3],
 "struct_parameters___lattice.html":[2,0,4],
 "struct_parameters___lattice.html#a1b59e1a307ad945fb86f44b68354f605":[2,0,4,3],
 "struct_parameters___lattice.html#a40f8633b47d204f471d041a0d8216e5b":[2,0,4,6],
diff --git a/docs/search/all_1.js b/docs/search/all_1.js
index 2827a6d..fc19deb 100644
--- a/docs/search/all_1.js
+++ b/docs/search/all_1.js
@@ -11,8 +11,9 @@ var searchData=
   ['checkfinished',['checkFinished',['../class_simulation.html#af69bb46977a3a0084214a194c888e16c',1,'Simulation']]],
   ['checkmovevalidity',['checkMoveValidity',['../class_lattice.html#ad0592298c4b92e9e84a768b95cd6d0f0',1,'Lattice']]],
   ['choosenextevent',['chooseNextEvent',['../class_simulation.html#af8cf2e5c24531582599423df2d70dc5b',1,'Simulation']]],
+  ['chooserandomunoccupiedneighbor',['chooseRandomUnoccupiedNeighbor',['../class_lattice.html#abf954e8213010ab8aeac7a0b93a869bc',1,'Lattice']]],
   ['clearoccupancy',['clearOccupancy',['../class_lattice.html#a97a1b4f24cd40b81ed63aa2d7713b63b',1,'Lattice::clearOccupancy()'],['../class_site.html#a46ff077954e39046b493ee1ea57a9c93',1,'Site::clearOccupancy()']]],
-  ['coords',['Coords',['../struct_coords.html',1,'']]],
-  ['createexponentialdosvector',['createExponentialDOSVector',['../namespace_utils.html#af296d2aa8f889f67fe515fc641c5f5fe',1,'Utils']]],
-  ['creategaussiandosvector',['createGaussianDOSVector',['../namespace_utils.html#a2ce45ade7d6d4f2995b595da3ebbaaec',1,'Utils']]]
+  ['coords',['Coords',['../struct_coords.html',1,'Coords'],['../struct_coords.html#a5922d1783cefa759950faa50ac347191',1,'Coords::Coords()'],['../struct_coords.html#a246211bba85765d5d67953922070d11f',1,'Coords::Coords(const int xval, const int yval, const int zval)']]],
+  ['createexponentialdosvector',['createExponentialDOSVector',['../namespace_utils.html#a62ed21bf039a062d34511cd016cd9b59',1,'Utils']]],
+  ['creategaussiandosvector',['createGaussianDOSVector',['../namespace_utils.html#aa92dbcc79f8336fcd2d9644db1a2b0ae',1,'Utils']]]
 ];
diff --git a/docs/search/all_4.js b/docs/search/all_4.js
index 148dbf5..612f209 100644
--- a/docs/search/all_4.js
+++ b/docs/search/all_4.js
@@ -4,7 +4,7 @@ var searchData=
   ['generaterandomx',['generateRandomX',['../class_lattice.html#ab78435e50e3bf9f376c04fc305785bb4',1,'Lattice']]],
   ['generaterandomy',['generateRandomY',['../class_lattice.html#a180a9d79a40b1a0a092c8ab489569700',1,'Lattice']]],
   ['generaterandomz',['generateRandomZ',['../class_lattice.html#a96006397a6ab389fb1eee87fde6e2165',1,'Lattice']]],
-  ['generator',['generator',['../class_simulation.html#a4c1d9071749e0fd93e70380cafb28417',1,'Simulation']]],
+  ['generator',['generator',['../class_simulation.html#a269659fa336a5563e2ccfe2db1654ba9',1,'Simulation']]],
   ['getalleventptrs',['getAllEventPtrs',['../class_simulation.html#aec6a6e1a80eb566685e4d257e6f872c5',1,'Simulation']]],
   ['getallobjectptrs',['getAllObjectPtrs',['../class_simulation.html#a620684b9ac1fb07344c4c2237ed9f352',1,'Simulation']]],
   ['getcoords',['getCoords',['../class_object.html#a08df08943dc634609fa69b356a37d73f',1,'Object']]],
@@ -19,6 +19,7 @@ var searchData=
   ['getlength',['getLength',['../class_lattice.html#a4b43b67a36fcd3dfe62c9eeaffa561d2',1,'Lattice']]],
   ['getn_5fevents',['getN_events',['../class_simulation.html#a7d88f18a1ba988d7e77b8be8de5b10d1',1,'Simulation']]],
   ['getn_5fevents_5fexecuted',['getN_events_executed',['../class_simulation.html#a52cb5564151421cbefaca56357738de7',1,'Simulation']]],
+  ['getn_5fobjects_5fcreated',['getN_objects_created',['../class_simulation.html#ab07386326b1844df84464abe30927bf5',1,'Simulation']]],
   ['getnumsites',['getNumSites',['../class_lattice.html#a4be17e9123f7737387991a9d1a8b87b3',1,'Lattice']]],
   ['getobjectptr',['getObjectPtr',['../class_event.html#a5317d42bb07d0e75bec0c13bd9bf6de8',1,'Event::getObjectPtr()'],['../class_site.html#aecb14e440914b4d3d4aa7294419791e2',1,'Site::getObjectPtr()']]],
   ['getobjecttargetptr',['getObjectTargetPtr',['../class_event.html#ab86f724c3c894faa1d6ccca78c357d24',1,'Event']]],
diff --git a/docs/search/all_6.js b/docs/search/all_6.js
index 0065d14..51422a5 100644
--- a/docs/search/all_6.js
+++ b/docs/search/all_6.js
@@ -4,7 +4,7 @@ var searchData=
   ['incrementdx',['incrementDX',['../class_object.html#a3d7c877f4aa179d9a56050c5faddc18d',1,'Object']]],
   ['incrementdy',['incrementDY',['../class_object.html#a9df010818be72d15bad7985bf8a89ba0',1,'Object']]],
   ['incrementdz',['incrementDZ',['../class_object.html#a440b267c478f5d63db1954bdbd543408',1,'Object']]],
-  ['init',['init',['../class_lattice.html#a2b0a88048fae662aa71386a3a123a260',1,'Lattice::init()'],['../class_simulation.html#af88e5e0634b373ba28f1dd87670725a6',1,'Simulation::init()']]],
+  ['init',['init',['../class_lattice.html#ab7322e5340badb9df4d208554fd90a89',1,'Lattice::init()'],['../class_simulation.html#af88e5e0634b373ba28f1dd87670725a6',1,'Simulation::init()']]],
   ['integratedata',['integrateData',['../namespace_utils.html#a49411c9d4c7a065dbcf237aa27a84023',1,'Utils']]],
   ['interpolatedata',['interpolateData',['../namespace_utils.html#af68995497777ee14d812c65991a4046f',1,'Utils']]],
   ['intpow',['intpow',['../namespace_utils.html#affd19edaa58a3f8425e1f7b4c9233f8a',1,'Utils']]],
diff --git a/docs/search/functions_1.js b/docs/search/functions_1.js
index 5b87205..fd55459 100644
--- a/docs/search/functions_1.js
+++ b/docs/search/functions_1.js
@@ -11,7 +11,9 @@ var searchData=
   ['checkfinished',['checkFinished',['../class_simulation.html#af69bb46977a3a0084214a194c888e16c',1,'Simulation']]],
   ['checkmovevalidity',['checkMoveValidity',['../class_lattice.html#ad0592298c4b92e9e84a768b95cd6d0f0',1,'Lattice']]],
   ['choosenextevent',['chooseNextEvent',['../class_simulation.html#af8cf2e5c24531582599423df2d70dc5b',1,'Simulation']]],
+  ['chooserandomunoccupiedneighbor',['chooseRandomUnoccupiedNeighbor',['../class_lattice.html#abf954e8213010ab8aeac7a0b93a869bc',1,'Lattice']]],
   ['clearoccupancy',['clearOccupancy',['../class_lattice.html#a97a1b4f24cd40b81ed63aa2d7713b63b',1,'Lattice::clearOccupancy()'],['../class_site.html#a46ff077954e39046b493ee1ea57a9c93',1,'Site::clearOccupancy()']]],
-  ['createexponentialdosvector',['createExponentialDOSVector',['../namespace_utils.html#af296d2aa8f889f67fe515fc641c5f5fe',1,'Utils']]],
-  ['creategaussiandosvector',['createGaussianDOSVector',['../namespace_utils.html#a2ce45ade7d6d4f2995b595da3ebbaaec',1,'Utils']]]
+  ['coords',['Coords',['../struct_coords.html#a5922d1783cefa759950faa50ac347191',1,'Coords::Coords()'],['../struct_coords.html#a246211bba85765d5d67953922070d11f',1,'Coords::Coords(const int xval, const int yval, const int zval)']]],
+  ['createexponentialdosvector',['createExponentialDOSVector',['../namespace_utils.html#a62ed21bf039a062d34511cd016cd9b59',1,'Utils']]],
+  ['creategaussiandosvector',['createGaussianDOSVector',['../namespace_utils.html#aa92dbcc79f8336fcd2d9644db1a2b0ae',1,'Utils']]]
 ];
diff --git a/docs/search/functions_4.js b/docs/search/functions_4.js
index f947895..ba897c6 100644
--- a/docs/search/functions_4.js
+++ b/docs/search/functions_4.js
@@ -18,6 +18,7 @@ var searchData=
   ['getlength',['getLength',['../class_lattice.html#a4b43b67a36fcd3dfe62c9eeaffa561d2',1,'Lattice']]],
   ['getn_5fevents',['getN_events',['../class_simulation.html#a7d88f18a1ba988d7e77b8be8de5b10d1',1,'Simulation']]],
   ['getn_5fevents_5fexecuted',['getN_events_executed',['../class_simulation.html#a52cb5564151421cbefaca56357738de7',1,'Simulation']]],
+  ['getn_5fobjects_5fcreated',['getN_objects_created',['../class_simulation.html#ab07386326b1844df84464abe30927bf5',1,'Simulation']]],
   ['getnumsites',['getNumSites',['../class_lattice.html#a4be17e9123f7737387991a9d1a8b87b3',1,'Lattice']]],
   ['getobjectptr',['getObjectPtr',['../class_event.html#a5317d42bb07d0e75bec0c13bd9bf6de8',1,'Event::getObjectPtr()'],['../class_site.html#aecb14e440914b4d3d4aa7294419791e2',1,'Site::getObjectPtr()']]],
   ['getobjecttargetptr',['getObjectTargetPtr',['../class_event.html#ab86f724c3c894faa1d6ccca78c357d24',1,'Event']]],
diff --git a/docs/search/functions_5.js b/docs/search/functions_5.js
index 0065d14..51422a5 100644
--- a/docs/search/functions_5.js
+++ b/docs/search/functions_5.js
@@ -4,7 +4,7 @@ var searchData=
   ['incrementdx',['incrementDX',['../class_object.html#a3d7c877f4aa179d9a56050c5faddc18d',1,'Object']]],
   ['incrementdy',['incrementDY',['../class_object.html#a9df010818be72d15bad7985bf8a89ba0',1,'Object']]],
   ['incrementdz',['incrementDZ',['../class_object.html#a440b267c478f5d63db1954bdbd543408',1,'Object']]],
-  ['init',['init',['../class_lattice.html#a2b0a88048fae662aa71386a3a123a260',1,'Lattice::init()'],['../class_simulation.html#af88e5e0634b373ba28f1dd87670725a6',1,'Simulation::init()']]],
+  ['init',['init',['../class_lattice.html#ab7322e5340badb9df4d208554fd90a89',1,'Lattice::init()'],['../class_simulation.html#af88e5e0634b373ba28f1dd87670725a6',1,'Simulation::init()']]],
   ['integratedata',['integrateData',['../namespace_utils.html#a49411c9d4c7a065dbcf237aa27a84023',1,'Utils']]],
   ['interpolatedata',['interpolateData',['../namespace_utils.html#af68995497777ee14d812c65991a4046f',1,'Utils']]],
   ['intpow',['intpow',['../namespace_utils.html#affd19edaa58a3f8425e1f7b4c9233f8a',1,'Utils']]],
diff --git a/docs/search/variables_1.js b/docs/search/variables_1.js
index eba0f65..969d096 100644
--- a/docs/search/variables_1.js
+++ b/docs/search/variables_1.js
@@ -1,4 +1,4 @@
 var searchData=
 [
-  ['generator',['generator',['../class_simulation.html#a4c1d9071749e0fd93e70380cafb28417',1,'Simulation']]]
+  ['generator',['generator',['../class_simulation.html#a269659fa336a5563e2ccfe2db1654ba9',1,'Simulation']]]
 ];
diff --git a/docs/struct_coords-members.html b/docs/struct_coords-members.html
index 17e11e1..adfdcbd 100644
--- a/docs/struct_coords-members.html
+++ b/docs/struct_coords-members.html
@@ -94,6 +94,8 @@
 
 <p>This is the complete list of members for <a class="el" href="struct_coords.html">Coords</a>, including all inherited members.</p>
 <table class="directory">
+  <tr class="even"><td class="entry"><a class="el" href="struct_coords.html#a5922d1783cefa759950faa50ac347191">Coords</a>()</td><td class="entry"><a class="el" href="struct_coords.html">Coords</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+  <tr><td class="entry"><a class="el" href="struct_coords.html#a246211bba85765d5d67953922070d11f">Coords</a>(const int xval, const int yval, const int zval)</td><td class="entry"><a class="el" href="struct_coords.html">Coords</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
   <tr class="even"><td class="entry"><a class="el" href="struct_coords.html#aaea2c566feec4e4bf56b27a34568be76">operator!=</a>(const Coords &amp;rhs) const</td><td class="entry"><a class="el" href="struct_coords.html">Coords</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
   <tr><td class="entry"><a class="el" href="struct_coords.html#ad3347f6568814df1a2b98b3cd0b78632">operator==</a>(const Coords &amp;rhs) const</td><td class="entry"><a class="el" href="struct_coords.html">Coords</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
   <tr class="even"><td class="entry"><a class="el" href="struct_coords.html#a88de3a6ee710766eb9c9444cee45a9f3">setXYZ</a>(const int xval, const int yval, const int zval)</td><td class="entry"><a class="el" href="struct_coords.html">Coords</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
diff --git a/docs/struct_coords.html b/docs/struct_coords.html
index 150a4c7..2c420f4 100644
--- a/docs/struct_coords.html
+++ b/docs/struct_coords.html
@@ -103,6 +103,13 @@
 <table class="memberdecls">
 <tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
 Public Member Functions</h2></td></tr>
+<tr class="memitem:a5922d1783cefa759950faa50ac347191"><td class="memItemLeft" align="right" valign="top"><a id="a5922d1783cefa759950faa50ac347191"></a>
+&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="struct_coords.html#a5922d1783cefa759950faa50ac347191">Coords</a> ()</td></tr>
+<tr class="memdesc:a5922d1783cefa759950faa50ac347191"><td class="mdescLeft">&#160;</td><td class="mdescRight">Default constructor that creates an empty <a class="el" href="struct_coords.html" title="This simple struct contains Cartesian coordinates specified by integers x,y,z. ">Coords</a> object. <br /></td></tr>
+<tr class="separator:a5922d1783cefa759950faa50ac347191"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a246211bba85765d5d67953922070d11f"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="struct_coords.html#a246211bba85765d5d67953922070d11f">Coords</a> (const int xval, const int yval, const int zval)</td></tr>
+<tr class="memdesc:a246211bba85765d5d67953922070d11f"><td class="mdescLeft">&#160;</td><td class="mdescRight">Constructor that creates a <a class="el" href="struct_coords.html" title="This simple struct contains Cartesian coordinates specified by integers x,y,z. ">Coords</a> object with the x,y,z coordinates set using the input values xval, yval, and zval.  <a href="#a246211bba85765d5d67953922070d11f">More...</a><br /></td></tr>
+<tr class="separator:a246211bba85765d5d67953922070d11f"><td class="memSeparator" colspan="2">&#160;</td></tr>
 <tr class="memitem:a88de3a6ee710766eb9c9444cee45a9f3"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="struct_coords.html#a88de3a6ee710766eb9c9444cee45a9f3">setXYZ</a> (const int xval, const int yval, const int zval)</td></tr>
 <tr class="memdesc:a88de3a6ee710766eb9c9444cee45a9f3"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets the x,y,z coordinates using the input values xval, yval, and zval.  <a href="#a88de3a6ee710766eb9c9444cee45a9f3">More...</a><br /></td></tr>
 <tr class="separator:a88de3a6ee710766eb9c9444cee45a9f3"><td class="memSeparator" colspan="2">&#160;</td></tr>
@@ -133,7 +140,60 @@
 <dl class="section copyright"><dt>Copyright</dt><dd>MIT License. For more information, see the LICENSE file that accompanies this software package. </dd></dl>
 <dl class="section author"><dt>Author</dt><dd>Michael C. Heiber </dd></dl>
 <dl class="section date"><dt>Date</dt><dd>2018 </dd></dl>
-</div><h2 class="groupheader">Member Function Documentation</h2>
+</div><h2 class="groupheader">Constructor &amp; Destructor Documentation</h2>
+<a id="a246211bba85765d5d67953922070d11f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a246211bba85765d5d67953922070d11f">&#9670;&nbsp;</a></span>Coords()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+  <tr>
+  <td class="mlabels-left">
+      <table class="memname">
+        <tr>
+          <td class="memname">Coords::Coords </td>
+          <td>(</td>
+          <td class="paramtype">const int&#160;</td>
+          <td class="paramname"><em>xval</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const int&#160;</td>
+          <td class="paramname"><em>yval</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const int&#160;</td>
+          <td class="paramname"><em>zval</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+  </td>
+  <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
+  </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructor that creates a <a class="el" href="struct_coords.html" title="This simple struct contains Cartesian coordinates specified by integers x,y,z. ">Coords</a> object with the x,y,z coordinates set using the input values xval, yval, and zval. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">xval</td><td>is the input x value. </td></tr>
+    <tr><td class="paramname">yval</td><td>is the input y value. </td></tr>
+    <tr><td class="paramname">zval</td><td>is the input z value. </td></tr>
+  </table>
+  </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
 <a id="aaea2c566feec4e4bf56b27a34568be76"></a>
 <h2 class="memtitle"><span class="permalink"><a href="#aaea2c566feec4e4bf56b27a34568be76">&#9670;&nbsp;</a></span>operator!=()</h2>
 
diff --git a/docs/struct_coords.js b/docs/struct_coords.js
index a6974be..b05b4f3 100644
--- a/docs/struct_coords.js
+++ b/docs/struct_coords.js
@@ -1,5 +1,7 @@
 var struct_coords =
 [
+    [ "Coords", "struct_coords.html#a5922d1783cefa759950faa50ac347191", null ],
+    [ "Coords", "struct_coords.html#a246211bba85765d5d67953922070d11f", null ],
     [ "operator!=", "struct_coords.html#aaea2c566feec4e4bf56b27a34568be76", null ],
     [ "operator==", "struct_coords.html#ad3347f6568814df1a2b98b3cd0b78632", null ],
     [ "setXYZ", "struct_coords.html#a88de3a6ee710766eb9c9444cee45a9f3", null ],

From c8515731e39b64152f1966632b9b6ac94b81c53a Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Tue, 15 May 2018 16:36:02 -0400
Subject: [PATCH 36/37] Lattice Class Testing Update

-reduced test calculation time for several tests
-added test for chooseRandomUnoccupiedNeighbor function when all
neighbor are occupied
---
 test/test.cpp | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/test/test.cpp b/test/test.cpp
index be6cae2..ef80417 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -796,7 +796,7 @@ namespace LatticeTests {
 
 	TEST_F(LatticeTest, RandomUnoccupiedNeighborTests) {
 		vector<int> data(30000);
-		for (int i = 0; i < 8; i++) {
+		for (int i = 0; i < 6; i++) {
 			Coords coords = lattice.generateRandomCoords();
 			for (auto& item : data) {
 				Coords coords_new = lattice.chooseRandomUnoccupiedNeighbor(coords);
@@ -811,6 +811,16 @@ namespace LatticeTests {
 				EXPECT_NEAR(1.0 / 6.0, (double)count/(double)data.size(), 1e-2);
 			}
 		}
+		// Check for correct output when all neighbor sites are occupied
+		Coords coords(5,5,5);
+		lattice.setOccupied(Coords(4,5,5));
+		lattice.setOccupied(Coords(6,5,5));
+		lattice.setOccupied(Coords(5,4,5));
+		lattice.setOccupied(Coords(5,6,5));
+		lattice.setOccupied(Coords(5,5,4));
+		lattice.setOccupied(Coords(5,5,6));
+		Coords coords_new = lattice.chooseRandomUnoccupiedNeighbor(coords);
+		EXPECT_TRUE(coords_new==Coords(-1,-1,-1));
 	}
 
 	TEST_F(LatticeTest, 2DTests) {
@@ -833,7 +843,7 @@ namespace LatticeTests {
 		lattice2D.setSitePointers(site_ptrs);
 		// Check random neighbor site generation in 2D
 		vector<int> data(30000);
-		for (int i = 0; i < 8; i++) {
+		for (int i = 0; i < 6; i++) {
 			Coords coords = lattice2D.generateRandomCoords();
 			for (auto& item : data) {
 				item = lattice2D.getSiteIndex(lattice2D.chooseRandomUnoccupiedNeighbor(coords));
@@ -868,7 +878,7 @@ namespace LatticeTests {
 		lattice1D.setSitePointers(site_ptrs);
 		// Check random neighbor site generation in 1D
 		vector<int> data(30000);
-		for (int i = 0; i < 8; i++) {
+		for (int i = 0; i < 6; i++) {
 			Coords coords = lattice1D.generateRandomCoords();
 			for (auto& item : data) {
 				item = lattice1D.getSiteIndex(lattice1D.chooseRandomUnoccupiedNeighbor(coords));

From 8d0768f03d0564235092339ed7bce712513627d1 Mon Sep 17 00:00:00 2001
From: "Michael C. Heiber" <mike.heiber@gmail.com>
Date: Tue, 15 May 2018 17:03:27 -0400
Subject: [PATCH 37/37] Readme Update

-edited the readme and corrected a few minor errors.
---
 README.md | 22 ++++++++--------------
 1 file changed, 8 insertions(+), 14 deletions(-)

diff --git a/README.md b/README.md
index f17fef4..54e0c68 100644
--- a/README.md
+++ b/README.md
@@ -7,15 +7,15 @@ The goal of this package is to be robust, reliable, and flexible so that users c
 
 This KMC_Lattice package implements several event recalculation options for creating computationally efficient simulations. 
 The package is designed to be usable on a personal computer and on high performance computing clusters. 
-Check out the [Excimontec](https://github.com/MikeHeiber/Excimontec) software package for an example of a complex tool constructed using KMC_Lattice, which is used for simulating organic semiconductor materials and devices.
+Check out the [Excimontec](https://github.com/MikeHeiber/Excimontec) software package for an example of a complex tool constructed using KMC_Lattice, which is used for simulating organic semiconductor devices.
 
-For further reading about kinetic Monte Carlo simulations, a nice overview of the theory and algorithm can be found here:
+For further reading about kinetic Monte Carlo simulations, a nice overview of the theory and algorithms can be found here:
 
 [Introduction to the Kinetic Monte Carlo Method by Arthur Voter, Los Alamos National Lab](http://www.fml.t.u-tokyo.ac.jp/~izumi/CMS/MC/Introduction_kMC.pdf)
 
 ## Current Status
 
-The current release is KMC_Lattice [![GitHub (pre-)release](https://img.shields.io/github/release/MikeHeiber/KMC_Lattice/all.svg?style=flat-square)](https://github.com/MikeHeiber/KMC_Lattice/releases) 
+The current release is KMC_Lattice [![GitHub (pre-)release](https://img.shields.io/github/release/MikeHeiber/KMC_Lattice/all.svg?style=flat-square)](https://github.com/MikeHeiber/KMC_Lattice/releases).
 Most major planned features that are to be included in v2.0 are now implemented and have undergone preliminary testing. 
 However, this software tool is still under development, and as such, there may still be bugs that need to be squashed. 
 Please report any bugs or submit feature requests in the [Issues](https://github.com/MikeHeiber/KMC_Lattice/issues) section. 
@@ -38,7 +38,7 @@ Code is being tested using [googletest](https://github.com/google/googletest) wi
 
 ## Contact
 
-If you would like to contribute to the development of this project or would like some help in using the tool for your research, please contact me (heiber@mailaps.org) to discuss a collaboration. 
+If you would like to contribute to the development of this project or would like some help in building an efficient KMC simulation tool for your specific scientific problem, please contact me (heiber@mailaps.org) to discuss a collaboration. 
 You can check out my KMC research and other work on [Researchgate](https://www.researchgate.net/profile/Michael_Heiber).
 
 ## How to try KMC_Lattice?
@@ -47,9 +47,8 @@ You can check out my KMC research and other work on [Researchgate](https://www.r
 
 This software tool uses [Message Passing Interface (MPI)](https://computing.llnl.gov/tutorials/mpi/) to utilize parallel computing power. 
 As a result, using KMC_Lattice requires that an MPI library is pre-installed on your system, and the final KMC_Lattice library must be built on your specific system. 
-We cannot provide pre-built binaries for your system. 
-Contact your HPC admin to determine the protocols for building MPI applications on your HPC system. 
-In many cases, the HPC system will already be configured for you, and the package comes with a default makefile that can be used with the [GCC compiler](https://gcc.gnu.org/) or the [PGI compiler](https://www.pgroup.com/). 
+Contact your HPC admin to determine the protocols for building MPI applications on your specific HPC system. 
+In many cases, the HPC system and environment will already be configured for you, and the package comes with a default makefile that can be used with the [GCC compiler](https://gcc.gnu.org/) or the [PGI compiler](https://www.pgroup.com/). 
 
 If you wish, you can also install MPI on your own personal workstation and then build the KMC_Lattice library there as well. For development and preliminary simulation tests, sometimes it is more efficient to run on your own workstation instead of an HPC system. More information about common MPI packages can be found here:
 - Open MPI, http://www.open-mpi.org/
@@ -57,17 +56,12 @@ If you wish, you can also install MPI on your own personal workstation and then
 - MVAPICH, http://mvapich.cse.ohio-state.edu/
 
 Once you have an MPI library installed, to build the KMC_Lattice library, copy the KMC_Lattice directory to your machine, set it as your working directory, and run `make`. 
-Compilation flags have been set for GCC and PGI compilers.  If you are using another compiler, you will need to edit the makefile and define your own compiler options.
+Compilation flags have been set for the GCC and PGI compilers.  If you are using another compiler, you may need to edit the makefile and define your own compiler options.
 However, before you use the KMC_Lattice library, you should test it on your own hardware using the unit and system tests provided. 
 Build the testing executable by running `make test`. 
 Once the test build is complete, run `./test/KMC_Lattice_tests.exe`.
 Please report any build or testing errors in the [Issues](https://github.com/MikeHeiber/KMC_Lattice/issues) section. 
 
-## Contact
-
-If you would like to contribute to the development of this project or would like some help in building an efficient KMC simulation tool for your specific scientific problem, please contact me to discuss a collaboration. 
-You can check out my KMC research and other work on [Researchgate](https://www.researchgate.net/profile/Michael_Heiber).
-
 ## Package Contents
 
 Object class - This base class can be extended to represent any entity that one would like to simulate. 
@@ -88,6 +82,6 @@ For example, site energies can be assigned to derived site classes to account fo
 Simulation class - This base class can be extended to manage all derived objects and their associated events. 
 The Simulation class contains the fundamental properties and back-end operations that most simulations would require.
 
-Utils - This file contain a number of useful utility functions, scientific constants, etc. that can then be used throughout the software package.
+Utils - This contains a number of useful utility functions, scientific constants, etc. that can then be used throughout the software package.
 
 Detailed API documentation for these classes and the entire KMC_Lattice package can be viewed [here](https://mikeheiber.github.io/KMC_Lattice/).