diff --git a/graph_framework/CMakeLists.txt b/graph_framework/CMakeLists.txt
index 270bde1a9b785b262758184cfa37fa09bce557f6..24a9b7d08dbee35de513e82beddd74fc1a7b76f0 100644
--- a/graph_framework/CMakeLists.txt
+++ b/graph_framework/CMakeLists.txt
@@ -45,6 +45,7 @@ target_precompile_headers (rays
                            $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/arithmetic.hpp>>
                            $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/backend.hpp>>
                            $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/dispersion.hpp>>
+                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/absorption.hpp>>
                            $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/math.hpp>>
                            $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/node.hpp>>
                            $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/solver.hpp>>
diff --git a/graph_framework/absorption.hpp b/graph_framework/absorption.hpp
index 9706dbd2d41f88abe4e8717c0a24dbd5987d9a9d..939099e006ebc70b7f59985010aba4ca5b5e10a2 100644
--- a/graph_framework/absorption.hpp
+++ b/graph_framework/absorption.hpp
@@ -1,6 +1,6 @@
 //------------------------------------------------------------------------------
-///  @file absoprtion.hpp
-///  @brief Base class for a dispersion relation.
+///  @file absorption.hpp
+///  @brief Base class for an absorption model.
 ///
 ///  Defines functions for computing power absorbtion.
 //------------------------------------------------------------------------------
@@ -11,6 +11,7 @@
 #include <thread>
 
 #include "newton.hpp"
+#include "output.hpp"
 
 namespace absorption {
 //******************************************************************************
diff --git a/graph_framework/arithmetic.hpp b/graph_framework/arithmetic.hpp
index 589d4decb24793815da9a396dcef4f9bc6f89de1..3d93efae652910797de7200d9850813c5e8979e0 100644
--- a/graph_framework/arithmetic.hpp
+++ b/graph_framework/arithmetic.hpp
@@ -8,7 +8,7 @@
 #ifndef arithmetic_h
 #define arithmetic_h
 
-#include "trigonometry.hpp"
+#include "node.hpp"
 
 namespace graph {
 //------------------------------------------------------------------------------
@@ -741,12 +741,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -1563,12 +1563,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -1822,8 +1822,8 @@ namespace graph {
             }
 
 //  Move trig to the right.
-            auto cl = graph::cos_cast(this->left);
-            auto sl = graph::sin_cast(this->left);
+            auto cl = cos_cast(this->left);
+            auto sl = sin_cast(this->left);
             if ((cl.get() && !this->right->is_power_like() &&
                  !this->right->is_all_variables() &&
                  !sin_cast(this->right).get()) ||
@@ -2455,12 +2455,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -3406,12 +3406,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -4837,12 +4837,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
diff --git a/graph_framework/math.hpp b/graph_framework/math.hpp
index f7fdfc0c0e34bf3764ae90d15f81161fc1ccdf99..7e58fa14bc8be2de30177e428a650ceaa7720081 100644
--- a/graph_framework/math.hpp
+++ b/graph_framework/math.hpp
@@ -279,12 +279,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -546,12 +546,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -786,12 +786,12 @@ namespace graph {
         auto temp = std::make_shared<log_node<T, SAFE_MATH>> (x)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -1289,12 +1289,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -1554,12 +1554,12 @@ namespace graph {
 //  Test for hash collisions.
         for (size_t i = temp->get_hash();
              i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
diff --git a/graph_framework/node.hpp b/graph_framework/node.hpp
index f9eb2c3492ea7308cf6bd2bc3652f403fa366189..ad1bd7c7698603f57f57de3f2de53f5fc288da90 100644
--- a/graph_framework/node.hpp
+++ b/graph_framework/node.hpp
@@ -311,12 +311,22 @@ namespace graph {
                    << std::endl;
         }
 
-///  Cache for constructed nodes.
-        inline thread_local static std::map<size_t,
-                                            std::shared_ptr<leaf_node<T, SAFE_MATH>>> cache;
-///  Cache for the backend buffers.
-        inline thread_local static std::map<size_t,
-                                            backend::buffer<T>> backend_cache;
+// Create one struct that holds both caches: for constructed nodes and for the backend buffers
+//------------------------------------------------------------------------------
+///  @brief Data structure to contain the two caches.
+///
+///  This a avoids an issue on gnu compilers where it would try to redefine the
+///  __tls_guard twice depending on the include order.
+//------------------------------------------------------------------------------
+        struct caches_t {
+///  Cache of node.
+            std::map<size_t, std::shared_ptr<leaf_node<T, SAFE_MATH>>> nodes;
+///  Cache of backend buffers.
+            std::map<size_t, backend::buffer<T>> backends;
+        };
+
+///  A per thread instance of the cache structure.
+        inline static thread_local caches_t caches;
 
 ///  Type def to retrieve the backend type.
         typedef T base;
@@ -593,12 +603,12 @@ namespace graph {
         auto temp = std::make_shared<constant_node<T, SAFE_MATH>> (d);
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -1368,7 +1378,7 @@ namespace graph {
     using input_nodes = std::vector<shared_variable<T, SAFE_MATH>>;
 ///  Convenience type alias for maping end codes back to inputs.
     template<jit::float_scalar T, bool SAFE_MATH=false>
-    using map_nodes = std::vector<std::pair<graph::shared_leaf<T, SAFE_MATH>,
+    using map_nodes = std::vector<std::pair<shared_leaf<T, SAFE_MATH>,
                                             shared_variable<T, SAFE_MATH>>>;
 
 //------------------------------------------------------------------------------
diff --git a/graph_framework/piecewise.hpp b/graph_framework/piecewise.hpp
index c1faaa410dc20e2df056927ac61f59d7c8365df6..d956f6f2d7fd1ff9bc52de9d7b4bbd298931f98c 100644
--- a/graph_framework/piecewise.hpp
+++ b/graph_framework/piecewise.hpp
@@ -116,11 +116,11 @@ void compile_index(std::ostringstream &stream,
         static size_t hash_data(const backend::buffer<T> &d) {
             const size_t h = std::hash<std::string>{} (piecewise_1D_node::to_string(d));
             for (size_t i = h; i < std::numeric_limits<size_t>::max(); i++) {
-                if (leaf_node<T, SAFE_MATH>::backend_cache.find(i) ==
-                    leaf_node<T, SAFE_MATH>::backend_cache.end()) {
-                    leaf_node<T, SAFE_MATH>::backend_cache[i] = d;
+                if (leaf_node<T, SAFE_MATH>::caches.backends.find(i) ==
+                    leaf_node<T, SAFE_MATH>::caches.backends.end()) {
+                    leaf_node<T, SAFE_MATH>::caches.backends[i] = d;
                     return i;
-                } else if (d == leaf_node<T, SAFE_MATH>::backend_cache[i]) {
+                } else if (d == leaf_node<T, SAFE_MATH>::caches.backends[i]) {
                     return i;
                 }
             }
@@ -156,7 +156,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns The evaluated value of the node.
 //------------------------------------------------------------------------------
         virtual backend::buffer<T> evaluate() {
-            return leaf_node<T, SAFE_MATH>::backend_cache[data_hash];
+            return leaf_node<T, SAFE_MATH>::caches.backends[data_hash];
         }
 
 //------------------------------------------------------------------------------
@@ -207,16 +207,16 @@ void compile_index(std::ostringstream &stream,
                                             visited, usage,
                                             textures1d, textures2d,
                                             avail_const_mem);
-                if (registers.find(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()) == registers.end()) {
-                    registers[leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()] =
-                        jit::to_string('a', leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data());
-                    const size_t length = leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+                if (registers.find(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()) == registers.end()) {
+                    registers[leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()] =
+                        jit::to_string('a', leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data());
+                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
                     if constexpr (jit::use_metal<T> ()) {
-                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                length);
 #ifdef USE_CUDA_TEXTURES
                     } else if constexpr (jit::use_cuda()) {
-                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                length);
 #endif
                     } else {
@@ -229,30 +229,30 @@ void compile_index(std::ostringstream &stream,
                         }
                         stream << "const ";
                         jit::add_type<T> (stream);
-                        stream << " " << registers[leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()] << "[] = {";
+                        stream << " " << registers[leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()] << "[] = {";
                         if constexpr (jit::is_complex<T> ()) {
                             jit::add_type<T> (stream);
                         }
-                        stream << leaf_node<T, SAFE_MATH>::backend_cache[data_hash][0];
+                        stream << leaf_node<T, SAFE_MATH>::caches.backends[data_hash][0];
                         for (size_t i = 1; i < length; i++) {
                             stream << ", ";
                             if constexpr (jit::is_complex<T> ()) {
                                 jit::add_type<T> (stream);
                             }
-                            stream << leaf_node<T, SAFE_MATH>::backend_cache[data_hash][i];
+                            stream << leaf_node<T, SAFE_MATH>::caches.backends[data_hash][i];
                         }
                         stream << "};" << std::endl;
                     }
                 } else {
 //  When using textures, the register can be defined in a previous kernel. We
 //  need to add the textures again.
-                    const size_t length = leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
                     if constexpr (jit::use_metal<T> ()) {
-                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                length);
 #ifdef USE_CUDA_TEXTURES
                     } else if constexpr (jit::use_cuda()) {
-                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures1d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                length);
 #endif
                     }
@@ -296,7 +296,7 @@ void compile_index(std::ostringstream &stream,
 #ifdef USE_INDEX_CACHE
                 if (indices.find(this->arg.get()) == indices.end()) {
 #endif
-                    const size_t length = leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
                     shared_leaf<T, SAFE_MATH> a = this->arg->compile(stream,
                                                                      registers,
                                                                      indices,
@@ -328,7 +328,7 @@ void compile_index(std::ostringstream &stream,
                     }
                 }
 #endif
-                stream << registers[leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()];
+                stream << registers[leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()];
                 if constexpr (jit::use_metal<T> ()) {
 #ifdef USE_INDEX_CACHE
                     stream << ".read("
@@ -435,7 +435,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns True the node has a zero constant value.
 //------------------------------------------------------------------------------
         virtual bool has_constant_zero() const {
-            return leaf_node<T, SAFE_MATH>::backend_cache[data_hash].has_zero();
+            return leaf_node<T, SAFE_MATH>::caches.backends[data_hash].has_zero();
         }
 
 //------------------------------------------------------------------------------
@@ -493,7 +493,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns The size of the buffer.
 //------------------------------------------------------------------------------
         size_t get_size() const {
-            return leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+            return leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
         }
     };
 
@@ -513,12 +513,12 @@ void compile_index(std::ostringstream &stream,
         auto temp = std::make_shared<piecewise_1D_node<T, SAFE_MATH>> (d, x)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -633,11 +633,11 @@ void compile_index(std::ostringstream &stream,
         static size_t hash_data(const backend::buffer<T> &d) {
             const size_t h = std::hash<std::string>{} (piecewise_2D_node::to_string(d));
             for (size_t i = h; i < std::numeric_limits<size_t>::max(); i++) {
-                if (leaf_node<T, SAFE_MATH>::backend_cache.find(i) ==
-                    leaf_node<T, SAFE_MATH>::backend_cache.end()) {
-                    leaf_node<T, SAFE_MATH>::backend_cache[i] = d;
+                if (leaf_node<T, SAFE_MATH>::caches.backends.find(i) ==
+                    leaf_node<T, SAFE_MATH>::caches.backends.end()) {
+                    leaf_node<T, SAFE_MATH>::caches.backends[i] = d;
                     return i;
-                } else if (d == leaf_node<T, SAFE_MATH>::backend_cache[i]) {
+                } else if (d == leaf_node<T, SAFE_MATH>::caches.backends[i]) {
                     return i;
                 }
             }
@@ -688,7 +688,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns The number of columns in the constant.
 //------------------------------------------------------------------------------
         size_t get_num_rows() const {
-            return leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size() /
+            return leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size() /
                    num_columns;
         }
 
@@ -702,7 +702,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns The evaluated value of the node.
 //------------------------------------------------------------------------------
         virtual backend::buffer<T> evaluate() {
-            return leaf_node<T, SAFE_MATH>::backend_cache[data_hash];
+            return leaf_node<T, SAFE_MATH>::caches.backends[data_hash];
         }
 
 //------------------------------------------------------------------------------
@@ -758,16 +758,16 @@ void compile_index(std::ostringstream &stream,
                                               visited, usage,
                                               textures1d, textures2d,
                                               avail_const_mem);
-                if (registers.find(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()) == registers.end()) {
-                    registers[leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()] =
-                        jit::to_string('a', leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data());
-                    const size_t length = leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+                if (registers.find(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()) == registers.end()) {
+                    registers[leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()] =
+                        jit::to_string('a', leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data());
+                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
                     if constexpr (jit::use_metal<T> ()) {
-                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                std::array<size_t, 2> ({length/num_columns, num_columns}));
 #ifdef USE_CUDA_TEXTURES
                     } else if constexpr (jit::use_cuda()) {
-                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                std::array<size_t, 2> ({length/num_columns, num_columns}));
 #endif
                     } else {
@@ -780,30 +780,30 @@ void compile_index(std::ostringstream &stream,
                         }
                         stream << "const ";
                         jit::add_type<T> (stream);
-                        stream << " " << registers[leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()] << "[] = {";
+                        stream << " " << registers[leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()] << "[] = {";
                         if constexpr (jit::is_complex<T> ()) {
                             jit::add_type<T> (stream);
                         }
-                        stream << leaf_node<T, SAFE_MATH>::backend_cache[data_hash][0];
+                        stream << leaf_node<T, SAFE_MATH>::caches.backends[data_hash][0];
                         for (size_t i = 1; i < length; i++) {
                             stream << ", ";
                             if constexpr (jit::is_complex<T> ()) {
                                 jit::add_type<T> (stream);
                             }
-                            stream << leaf_node<T, SAFE_MATH>::backend_cache[data_hash][i];
+                            stream << leaf_node<T, SAFE_MATH>::caches.backends[data_hash][i];
                         }
                         stream << "};" << std::endl;
                     }
                 } else {
 //  When using textures, the register can be defined in a previous kernel. We
 //  need to add the textures again.
-                    const size_t length = leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+                    const size_t length = leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
                     if constexpr (jit::use_metal<T> ()) {
-                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                std::array<size_t, 2> ({length/num_columns, num_columns}));
 #ifdef USE_CUDA_TEXTURES
                     } else if constexpr (jit::use_cuda()) {
-                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data(),
+                        textures2d.try_emplace(leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data(),
                                                std::array<size_t, 2> ({length/num_columns, num_columns}));
 #endif
                     }
@@ -857,7 +857,7 @@ void compile_index(std::ostringstream &stream,
                 jit::register_map &indices,
                 const jit::register_usage &usage) {
             if (registers.find(this) == registers.end()) {
-                const size_t length = leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+                const size_t length = leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
                 const size_t num_rows = length/num_columns;
 
 #ifdef USE_INDEX_CACHE
@@ -898,7 +898,7 @@ void compile_index(std::ostringstream &stream,
                              ) {
                     if (indices.find(temp.get()) == indices.end()) {
                         indices[temp.get()] = jit::to_string('i', temp.get());
-                        const size_t length = leaf_node<T, SAFE_MATH>::backend_cache[data_hash].size();
+                        const size_t length = leaf_node<T, SAFE_MATH>::caches.backends[data_hash].size();
                         stream << "        const "
                                << jit::smallest_int_type<T> (length) << " "
                                << indices[temp.get()] << " = "
@@ -927,7 +927,7 @@ void compile_index(std::ostringstream &stream,
                     }
                 }
 #endif
-                stream << registers[leaf_node<T, SAFE_MATH>::backend_cache[data_hash].data()];
+                stream << registers[leaf_node<T, SAFE_MATH>::caches.backends[data_hash].data()];
                 if constexpr (jit::use_metal<T> ()) {
 #ifdef USE_INDEX_CACHE
                     stream << ".read("
@@ -1051,7 +1051,7 @@ void compile_index(std::ostringstream &stream,
 ///  @returns True the node has a zero constant value.
 //------------------------------------------------------------------------------
         virtual bool has_constant_zero() const {
-            return leaf_node<T, SAFE_MATH>::backend_cache[data_hash].has_zero();
+            return leaf_node<T, SAFE_MATH>::caches.backends[data_hash].has_zero();
         }
 
 //------------------------------------------------------------------------------
@@ -1154,12 +1154,12 @@ void compile_index(std::ostringstream &stream,
         auto temp = std::make_shared<piecewise_2D_node<T, SAFE_MATH>> (d, n, x, y)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
diff --git a/graph_framework/trigonometry.hpp b/graph_framework/trigonometry.hpp
index 19ef146889005653f9f04fcbad898b7fff694822..d5fd80ef685e87a90c8147d5e8c755ae55928524 100644
--- a/graph_framework/trigonometry.hpp
+++ b/graph_framework/trigonometry.hpp
@@ -228,12 +228,12 @@ namespace graph {
         auto temp = std::make_shared<sine_node<T, SAFE_MATH>> (x)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -478,12 +478,12 @@ namespace graph {
         auto temp = std::make_shared<cosine_node<T, SAFE_MATH>> (x)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
@@ -798,12 +798,12 @@ namespace graph {
         auto temp = std::make_shared<arctan_node<T, SAFE_MATH>> (l, r)->reduce();
 //  Test for hash collisions.
         for (size_t i = temp->get_hash(); i < std::numeric_limits<size_t>::max(); i++) {
-            if (leaf_node<T, SAFE_MATH>::cache.find(i) ==
-                leaf_node<T, SAFE_MATH>::cache.end()) {
-                leaf_node<T, SAFE_MATH>::cache[i] = temp;
+            if (leaf_node<T, SAFE_MATH>::caches.nodes.find(i) ==
+                leaf_node<T, SAFE_MATH>::caches.nodes.end()) {
+                leaf_node<T, SAFE_MATH>::caches.nodes[i] = temp;
                 return temp;
-            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::cache[i])) {
-                return leaf_node<T, SAFE_MATH>::cache[i];
+            } else if (temp->is_match(leaf_node<T, SAFE_MATH>::caches.nodes[i])) {
+                return leaf_node<T, SAFE_MATH>::caches.nodes[i];
             }
         }
 #if defined(__clang__) || defined(__GNUC__)
diff --git a/graph_tests/efit_test.cpp b/graph_tests/efit_test.cpp
index 13c1a14b5d4aa05f92c8c02f22e927193423b1f5..c8d749ca80013a781276b5577d382a4b6172eaca 100644
--- a/graph_tests/efit_test.cpp
+++ b/graph_tests/efit_test.cpp
@@ -14,7 +14,6 @@
 #include <netcdf.h>
 
 #include "equilibrium.hpp"
-#include "workflow.hpp"
 
 //------------------------------------------------------------------------------
 ///  @brief Class interface for gold data.