Index: src/LinkedCell/LinkedCell_Controller.cpp
===================================================================
--- src/LinkedCell/LinkedCell_Controller.cpp	(revision 0773bdd30e9bd9334bfac9cd1fd6cbf2a6fce929)
+++ src/LinkedCell/LinkedCell_Controller.cpp	(revision 1d2d01ed7d609f7ea5e51dc8825133772d41911b)
@@ -116,20 +116,30 @@
 }
 
-/** Internal function to decide whether a suitable model is present or not.
- *
- * Here, the heuristic for deciding whether a new linked cell structure has to
- * be constructed or not is implemented. The current heuristic is as follows:
- * -# the best model should have at least half the desired length (such
- *    that most we have to look two neighbor shells wide and not one).
- * -# the best model should have at most twice the desired length but
- *    no less than 1 angstroem.
- *
- * \note Dealing out a pointer is here (hopefully) safe because the function is
- * internal and we - inside this class - know what we are doing.
- *
- * @param distance edge length of the requested linked cell structure
- * @return NULL - there is no fitting LinkedCell_Model, else - pointer to instance
- */
-const LinkedCell_Model *LinkedCell_Controller::getBestModel(double distance) const
+static size_t checkLengthsLess(
+    const Vector &Lengths,
+    const double min_distance)
+{
+  size_t counter=0;
+  for (size_t i=0;i<NDIM;++i) {
+    if (Lengths[i] < min_distance)
+      ++counter;
+  }
+  return counter;
+}
+
+/** Given some given \a distance return it such that it is larger equal than some minimum
+ * sensible value with respect to the current domain.
+ *
+ * The sensible minimum distance \f$\Delta\f$ is computed as follows:
+ * \f$ \frac {l_1} \Delta \frac {l_2} \Delta \frac {l_3} \Delta \leq M \f$, where M is the
+ * maximum number of linked cells. Where some additional thought must be given
+ * to rounding issues. Hence, we calculate \f$ (\frac {l_i} d)^{\frac 1 d}+.5\f$,
+ * where d is the assumed dimensionality of the domain: d=3 for cubic, d=2 for
+ * a planar, d=1 for a bar-like system.
+ *
+ * \param distance distance compared with minimum value
+ * \return minimum sensible value or \a distance if larger
+ */
+double LinkedCell_Controller::getMinimumSensibleLength(double distance) const
 {
   // first check the box with respect to the given distance
@@ -141,11 +151,23 @@
   UnitMatrix *= M;
   Vector Lengths = UnitMatrix.transformToEigenbasis();
-  double min_distance = std::numeric_limits<double>::max();
   double max_length = 0.;
-  for (size_t i=0;i<NDIM;++i) {
-    min_distance = std::min(Lengths[i], min_distance);
-    max_length = std::max(Lengths[i], max_length);
-  }
-  min_distance *= 1e-3; // at most 1000 cells per axis
+  double volume = 1.;
+  double min_distance = lower_threshold;
+  for (size_t dim=NDIM; dim>0; --dim) {
+    const double fraction = pow(MAX_LINKEDCELLNODES+1., 1./(double)dim);
+    for (size_t i=0;i<NDIM;++i) {
+      max_length = std::max(Lengths[i], max_length);
+      // the length dropping out for dimensionality less than 3 must appear
+      // just as factor of 1 not less.
+      if (Lengths[i] < min_distance)
+        volume *= pow(min_distance, 1./(double)dim)+.5;
+      else
+        volume *= pow(Lengths[i], 1./(double)dim)+.5; //.5 for rounding issues
+    }
+    min_distance = volume/fraction;
+    // assuming a (cubic-like) 3d system
+    if (checkLengthsLess(Lengths, min_distance) == 0)
+      break;
+  }
   if (distance < min_distance) {
     LOG(1, "INFO: Setting LC distance from given " << distance
@@ -153,5 +175,24 @@
     distance = min_distance;
   }
-
+  return distance;
+}
+
+/** Internal function to decide whether a suitable model is present or not.
+ *
+ * Here, the heuristic for deciding whether a new linked cell structure has to
+ * be constructed or not is implemented. The current heuristic is as follows:
+ * -# the best model should have at least half the desired length (such
+ *    that most we have to look two neighbor shells wide and not one).
+ * -# the best model should have at most twice the desired length but
+ *    no less than 1 angstroem.
+ *
+ * \note Dealing out a pointer is here (hopefully) safe because the function is
+ * internal and we - inside this class - know what we are doing.
+ *
+ * @param distance edge length of the requested linked cell structure
+ * @return NULL - there is no fitting LinkedCell_Model, else - pointer to instance
+ */
+const LinkedCell_Model *LinkedCell_Controller::getBestModel(double distance) const
+{
   /// Bound distance to be within [lower_threshold, upper_threshold).
   /// Note that we need to stay away from upper boundary a bit,
@@ -159,6 +200,6 @@
   if (distance < lower_threshold)
     distance = lower_threshold;
-  if (distance > max_length)
-    distance = max_length - std::numeric_limits<double>::round_error();
+  if (distance > upper_threshold)
+    distance = upper_threshold - std::numeric_limits<double>::round_error();
 
   /// Look for all models within [0.5 distance, 2. distance).
@@ -210,12 +251,15 @@
 LinkedCell_View LinkedCell_Controller::getView(const double distance, IPointCloud &set)
 {
+  // distance should be a given minimum length dependent on domain at least
+  const double ConstraintDistance = getMinimumSensibleLength(distance);
+
   /// Look for best instance.
-  const LinkedCell_Model * const LCModel_best = getBestModel(distance);
+  const LinkedCell_Model * const LCModel_best = getBestModel(ConstraintDistance);
 
   /// Construct new instance if none found,
   if (LCModel_best == NULL) {
-    LinkedCell_Model * const LCModel_new = new LinkedCell_Model(distance, domain);
+    LinkedCell_Model * const LCModel_new = new LinkedCell_Model(ConstraintDistance, domain);
     LCModel_new->insertPointCloud(set);
-    insertNewModel(distance, LCModel_new);
+    insertNewModel(ConstraintDistance, LCModel_new);
     LinkedCell_View view(*LCModel_new);
     return view;
Index: src/LinkedCell/LinkedCell_Controller.hpp
===================================================================
--- src/LinkedCell/LinkedCell_Controller.hpp	(revision 0773bdd30e9bd9334bfac9cd1fd6cbf2a6fce929)
+++ src/LinkedCell/LinkedCell_Controller.hpp	(revision 1d2d01ed7d609f7ea5e51dc8825133772d41911b)
@@ -61,4 +61,6 @@
     void updateModels();
 
+    double getMinimumSensibleLength(double distance) const;
+
   private:
     //!> typedef for the (edge length, model) map
