Index: src/LinkedCell/LinkedCell_Model.cpp
===================================================================
--- src/LinkedCell/LinkedCell_Model.cpp	(revision c806430dd9192196eecf5a8e808273f583a12492)
+++ src/LinkedCell/LinkedCell_Model.cpp	(revision 53d894c34a1a8ff0f2e679e04918aa717133bfd4)
@@ -351,6 +351,14 @@
       break;
     case Box::Bounce:
+      if (index[i] < 0)
+        index[i] = 0;
+      if (index[i] >= getSize(i))
+        index[i] = getSize(i)-1;
       break;
     case Box::Ignore:
+      if (index[i] < 0)
+        index[i] = 0;
+      if (index[i] >= getSize(i))
+        index[i] = getSize(i)-1;
       break;
     default:
@@ -362,4 +370,7 @@
 
 /** Calculates the interval bounds of the linked cell grid.
+ *
+ * \note we assume for index to allows be valid, i.e. within the range of LinkedCell_Model::N.
+ *
  * \param index index to give relative bounds to
  * \param step how deep to check the neighbouring cells (i.e. number of layers to check)
@@ -375,45 +386,39 @@
   // calculate bounds
   for (size_t i=0;i<NDIM;++i) {
+    ASSERT(index[i] >= 0,
+        "LinkedCell_Model::getNeighborhoodBounds() - index "+toString(index)+" out of lower bounds.");
+    ASSERT (index[i] < getSize(i),
+        "LinkedCell_Model::getNeighborhoodBounds() - index "+toString(index)+" out of upper bounds.");
     switch (domain.getConditions()[i]) {
       case Box::Wrap:
+        if ((index[i] - step[i]) < 0)
+          neighbors.first[i] = getSize(i) + (index[i] - step[i]);
+        else if ((index[i] - step[i]) >= getSize(i))
+          neighbors.first[i] = (index[i] - step[i]) - getSize(i);
+        else
+          neighbors.first[i] = index[i] - step[i];
+        neighbors.second[i] = 2*step[i]+1;
+        break;
+      case Box::Bounce:
+        neighbors.second[i] = 2*step[i]+1;
         if (index[i] - step[i] >= 0) {
           neighbors.first[i] = index[i] - step[i];
         } else {
-          neighbors.first[i] = getSize(i) - (index[i] - step[i]);
+          neighbors.first[i] = 0;
+          neighbors.second[i] = index[i] + step[i]+1;
         }
-        if (index[i] + step[i] < getSize(i)) {
-          neighbors.second[i] = index[i] + step[i];
-        } else {
-          neighbors.second[i] = index[i] + step[i] - getSize(i);
+        if (index[i] + step[i] >= getSize(i)) {
+          neighbors.second[i] = getSize(i) - (index[i] - step[i]);
         }
         break;
-      case Box::Bounce:
-        if (index[i] - step[i] >= 0) {
+      case Box::Ignore:
+        if (index[i] - step[i] < 0)
+          neighbors.first[i] = 0;
+        else
           neighbors.first[i] = index[i] - step[i];
-        } else {
-          neighbors.first[i] = - (index[i] - step[i]);
-        }
-        if (index[i] + step[i] < getSize(i)) {
-          neighbors.second[i] = index[i] + step[i];
-        } else {
-          const size_t shift = index[i] + step[i];
-          const size_t mod = shift / getSize(i);
-          if ((mod / 2)*2 == mod) // even -> come in from lower bound
-            neighbors.second[i] = (shift % getSize(i));
-          else // odd -> come in from upper bound
-            neighbors.second[i] = getSize(i) - (shift % getSize(i));
-        }
-        break;
-      case Box::Ignore:
-        ASSERT(index[i] - step[i] >= 0,
-            "LinkedCell_Model::getNeighborhoodBounds() - lower out of bounds on 'Ignore' boundary conditions");
-        neighbors.first[i] = index[i] - step[i];
-        ASSERT (index[i] + step[i] < getSize(i),
-            "LinkedCell_Model::getNeighborhoodBounds() - upper out of bounds on 'Ignore' boundary conditions");
-        neighbors.second[i] = index[i] + step[i];
-        ASSERT(neighbors.second[i] < neighbors.first[i],
-            "LinkedCell_Model::getNeighborhoodBounds() - ["
-            +toString(neighbors.first[i])+","+toString(neighbors.second[i])
-            +"] does not make sense as array bounds.");
+        if (index[i] + step[i] >= getSize(i))
+          neighbors.second[i] = getSize(i) - index[i];
+        else
+          neighbors.second[i] = 2*step[i]+1;
         break;
       default:
Index: src/LinkedCell/LinkedCell_Model.hpp
===================================================================
--- src/LinkedCell/LinkedCell_Model.hpp	(revision c806430dd9192196eecf5a8e808273f583a12492)
+++ src/LinkedCell/LinkedCell_Model.hpp	(revision 53d894c34a1a8ff0f2e679e04918aa717133bfd4)
@@ -60,4 +60,5 @@
     bool checkArrayBounds(const tripleIndex &index) const;
     void applyBoundaryConditions(tripleIndex &index) const;
+    bool empty() const { return CellLookup.size() == 0; }
 
     void addNode(const TesselPoint *Walker);
Index: src/LinkedCell/LinkedCell_View.cpp
===================================================================
--- src/LinkedCell/LinkedCell_View.cpp	(revision c806430dd9192196eecf5a8e808273f583a12492)
+++ src/LinkedCell/LinkedCell_View.cpp	(revision 53d894c34a1a8ff0f2e679e04918aa717133bfd4)
@@ -22,4 +22,6 @@
 #include "LinkedCell_View.hpp"
 
+#include "CodePatterns/Log.hpp"
+
 #include "Atom/TesselPoint.hpp"
 #include "LinearAlgebra/Vector.hpp"
@@ -37,4 +39,5 @@
 {
 }
+
 
 /** Return at least as many points as are inside a sphere of \a radius around \a center.
@@ -57,11 +60,12 @@
 
   tripleIndex n;
-  for (n[0] = neighbors.first[0]; n[0] <= neighbors.second[0]; n[0]++)
-    for (n[1] = neighbors.first[1]; n[1] <= neighbors.second[1]; n[1]++)
-      for (n[2] = neighbors.first[2]; n[2] <= neighbors.second[2]; n[2]++) {
-        if (!LC.checkArrayBounds(n))
-          LC.applyBoundaryConditions(n);
-        const LinkedCell &List = LC.getCell(n);
-        //LOG(1, "Current cell is " << n[0] << ", " << n[1] << ", " << n[2] << " with No. " << index << ".");
+  for (n[0] = 0; n[0] < neighbors.second[0]; n[0]++)
+    for (n[1] = 0; n[1] < neighbors.second[1]; n[1]++)
+      for (n[2] = 0; n[2] < neighbors.second[2]; n[2]++) {
+        tripleIndex absolute_n = neighbors.first + n;
+        if (!LC.checkArrayBounds(absolute_n))
+          LC.applyBoundaryConditions(absolute_n);
+        const LinkedCell &List = LC.getCell(absolute_n);
+        LOG(1, "Current cell is " << neighbors.first << " plus " << n << ", yielding " << absolute_n << ".");
         for (LinkedCell::const_iterator Runner = List.begin(); Runner != List.end(); Runner++)
           TesselList.push_back(*Runner);
@@ -84,3 +88,2 @@
   return ReturnList;
 }
-
