Index: src/Fragmentation/Automation/FragmentationChargeDensity.cpp
===================================================================
--- src/Fragmentation/Automation/FragmentationChargeDensity.cpp	(revision 69e065666b610d9348120ce282aabfeb2adc7149)
+++ src/Fragmentation/Automation/FragmentationChargeDensity.cpp	(revision b8f0b250c2143e3d8e7c3b8ef67750ab6eccc8b1)
@@ -93,10 +93,10 @@
 
   /// convert all MPQCData to MPQCDataMap_t
-  Result_Grid_fused =
-    OrthogonalSumUpPerLevel<MPQCDataGridMap_t, MPQCData, MPQCDataGridVector_t>(
-        fragmentData, MatrixNrLookup, container, subsetmap);
-  Result_Fragment_fused =
-    OrthogonalSumUpPerLevel<MPQCDataFragmentMap_t, MPQCData, MPQCDataFragmentVector_t>(
-        fragmentData, MatrixNrLookup, container, subsetmap);
+  OrthogonalSumUpPerLevel<MPQCDataGridMap_t, MPQCData, MPQCDataGridVector_t>(
+      fragmentData, MatrixNrLookup, container, subsetmap,
+      Result_Grid_fused, Result_perIndexSet_Grid);
+  OrthogonalSumUpPerLevel<MPQCDataFragmentMap_t, MPQCData, MPQCDataFragmentVector_t>(
+      fragmentData, MatrixNrLookup, container, subsetmap,
+      Result_Fragment_fused, Result_perIndexSet_Fragment);
 }
 
Index: src/Fragmentation/Automation/FragmentationChargeDensity.hpp
===================================================================
--- src/Fragmentation/Automation/FragmentationChargeDensity.hpp	(revision 69e065666b610d9348120ce282aabfeb2adc7149)
+++ src/Fragmentation/Automation/FragmentationChargeDensity.hpp	(revision b8f0b250c2143e3d8e7c3b8ef67750ab6eccc8b1)
@@ -22,4 +22,5 @@
 
 #include "Fragmentation/SetValues/Fragment.hpp"
+#include "Fragmentation/Summation/IndexSet.hpp"
 #include "Jobs/MPQCData.hpp"
 #include "Jobs/MPQCDataMap.hpp"
@@ -44,7 +45,13 @@
   const Fragment &getFragment();
 
+  //!> results per level of summed up sampled grid charge
   std::vector<MPQCDataGridMap_t> Result_Grid_fused;
+  //!> results per level of summed up fragment positions and charges
+  std::vector<MPQCDataFragmentMap_t> Result_Fragment_fused;
 
-  std::vector<MPQCDataFragmentMap_t> Result_Fragment_fused;
+  //!> results per IndexSet of summed up sampled grid charge
+  std::map<IndexSet::ptr, MPQCDataGridMap_t> Result_perIndexSet_Grid;
+  //!> results per IndexSet of summed up fragment positions and charges
+  std::map<IndexSet::ptr, MPQCDataFragmentMap_t> Result_perIndexSet_Fragment;
 };
 
Index: src/Fragmentation/Automation/FragmentationResults.cpp
===================================================================
--- src/Fragmentation/Automation/FragmentationResults.cpp	(revision 69e065666b610d9348120ce282aabfeb2adc7149)
+++ src/Fragmentation/Automation/FragmentationResults.cpp	(revision b8f0b250c2143e3d8e7c3b8ef67750ab6eccc8b1)
@@ -121,16 +121,16 @@
 
     typedef boost::mpl::remove<MPQCDataEnergyVector_t, MPQCDataFused::energy_eigenvalues>::type MPQCDataEnergyVector_noeigenvalues_t;
-    Result_Energy_fused =
-        OrthogonalSumUpPerLevel<MPQCDataEnergyMap_t, MPQCData, MPQCDataEnergyVector_t>(
-            fragmentData, MPQCMatrixNrLookup, container, subsetmap);
-    Result_Grid_fused =
-      OrthogonalSumUpPerLevel<MPQCDataGridMap_t, MPQCData, MPQCDataGridVector_t>(
-          fragmentData, MPQCMatrixNrLookup, container, subsetmap);
-    Result_Time_fused =
-      SumUpPerLevel<MPQCDataTimeMap_t, MPQCData, MPQCDataTimeVector_t>(
-          fragmentData, MPQCMatrixNrLookup, container, subsetmap);
-    Result_Fragment_fused =
-      OrthogonalSumUpPerLevel<MPQCDataFragmentMap_t, MPQCData, MPQCDataFragmentVector_t>(
-          fragmentData, MPQCMatrixNrLookup, container, subsetmap);
+    OrthogonalSumUpPerLevel<MPQCDataEnergyMap_t, MPQCData, MPQCDataEnergyVector_t>(
+        fragmentData, MPQCMatrixNrLookup, container, subsetmap,
+        Result_Energy_fused, Result_perIndexSet_Energy);
+    OrthogonalSumUpPerLevel<MPQCDataGridMap_t, MPQCData, MPQCDataGridVector_t>(
+        fragmentData, MPQCMatrixNrLookup, container, subsetmap,
+        Result_Grid_fused, Result_perIndexSet_Grid);
+    SumUpPerLevel<MPQCDataTimeMap_t, MPQCData, MPQCDataTimeVector_t>(
+        fragmentData, MPQCMatrixNrLookup, container, subsetmap,
+        Result_Time_fused, Result_perIndexSet_Time);
+    OrthogonalSumUpPerLevel<MPQCDataFragmentMap_t, MPQCData, MPQCDataFragmentVector_t>(
+        fragmentData, MPQCMatrixNrLookup, container, subsetmap,
+        Result_Fragment_fused, Result_perIndexSet_Fragment);
 
     // multiply each short-range potential with the respective charge
@@ -141,7 +141,7 @@
     }
     // then sum up
-    Result_LongRange_fused =
-      OrthogonalSumUpPerLevel<VMGDataMap_t, VMGData, VMGDataVector_t>(
-          longrangeData, VMGMatrixNrLookup, container, subsetmap);
+    OrthogonalSumUpPerLevel<VMGDataMap_t, VMGData, VMGDataVector_t>(
+        longrangeData, VMGMatrixNrLookup, container, subsetmap,
+        Result_LongRange_fused, Result_perIndexSet_LongRange);
 
     // force has extra data converter
@@ -154,5 +154,6 @@
                 container->getContainer(),
                 MPQCMatrixNrLookup,
-                Result_Force_fused);
+                Result_Force_fused,
+                Result_perIndexSet_Force);
     boost::mpl::for_each<MPQCDataForceVector_t>(boost::ref(forceSummer));
 
Index: src/Fragmentation/Automation/FragmentationResults.hpp
===================================================================
--- src/Fragmentation/Automation/FragmentationResults.hpp	(revision 69e065666b610d9348120ce282aabfeb2adc7149)
+++ src/Fragmentation/Automation/FragmentationResults.hpp	(revision b8f0b250c2143e3d8e7c3b8ef67750ab6eccc8b1)
@@ -20,4 +20,6 @@
 
 #include "JobMarket/types.hpp"
+
+#include "Fragmentation/Summation/IndexSet.hpp"
 
 #include "Jobs/MPQCData.hpp"
@@ -75,4 +77,19 @@
   std::vector<VMGDataLongRangeMap_t> Result_LongRangeIntegrated_fused;
 
+  //!> results per IndexSet of summed up energy
+  std::map<IndexSet::ptr, MPQCDataEnergyMap_t> Result_perIndexSet_Energy;
+  //!> results per IndexSet of summed up sampled grid charge
+  std::map<IndexSet::ptr, MPQCDataGridMap_t> Result_perIndexSet_Grid;
+  //!> results per IndexSet of summed up times
+  std::map<IndexSet::ptr, MPQCDataTimeMap_t> Result_perIndexSet_Time;
+  //!> results per IndexSet of summed up fragment positions and charges
+  std::map<IndexSet::ptr, MPQCDataFragmentMap_t> Result_perIndexSet_Fragment;
+  //!> results per IndexSet of summed up forces
+  std::map<IndexSet::ptr, MPQCDataForceMap_t> Result_perIndexSet_Force;
+  //!> results per IndexSet of summed up long range potential grids and energy
+  std::map<IndexSet::ptr, VMGDataMap_t> Result_perIndexSet_LongRange;
+  // we don't need the map pendant for Result_LongRangeIntegrated_fused, as this
+  // quantity makes sense only level-wise
+
 private:
   //!> maximum level of summation
Index: src/Fragmentation/Summation/AllLevelOrthogonalSummator.hpp
===================================================================
--- src/Fragmentation/Summation/AllLevelOrthogonalSummator.hpp	(revision 69e065666b610d9348120ce282aabfeb2adc7149)
+++ src/Fragmentation/Summation/AllLevelOrthogonalSummator.hpp	(revision b8f0b250c2143e3d8e7c3b8ef67750ab6eccc8b1)
@@ -45,12 +45,14 @@
       const IndexSetContainer::Container_t &_container,
       const std::map< JobId_t, size_t > &_MatrixNrLookup,
-      std::vector<MapType> &_results) :
+      std::vector<MapType> &_levelresults,
+      std::map<IndexSet::ptr, MapType> &_keysetresults) :
     subsetmap(_subsetmap),
     data(_data),
     container(_container),
     MatrixNrLookup(_MatrixNrLookup),
-    results(_results)
+    levelresults(_levelresults),
+    keysetresults(_keysetresults)
   {
-    ASSERT( results.size() >= subsetmap->getMaximumSetLevel(),
+    ASSERT( levelresults.size() >= subsetmap->getMaximumSetLevel(),
         "AllLevelOrthogonalSummator() - result vector is not large enough.");
   }
@@ -65,16 +67,28 @@
     // We retrieve the type of the MPQCData member variable from the boost::fusion::map.
     typedef typename boost::fusion::result_of::value_at_key<MapType, MapKey>::type MapValue;
+
     // create OrthogonalSummator instance
     OrthogonalSummator<MapType, MapKey> sum_value(
         subsetmap, data, container, MatrixNrLookup
         );
+
+    // fill levelresults
     const size_t MaxLevel = subsetmap->getMaximumSetLevel();
     for (size_t level=1; level <= MaxLevel; ++level) {
-      MapType &LevelResults = results[level-1];
-      // sum up and store in results
+      MapType &LevelResults = levelresults[level-1];
+      // sum up and store in levelresults
       const MapValue value = sum_value(level);
       boost::fusion::at_key<MapKey>(LevelResults) = value;
       // print value
       //LOG(0, "STATUS: Level " << level << " resulting " << printKeyNames::printName<MapKey>() << " is " << value << ".");
+    }
+
+    // fill keysetresults
+    for (IndexSetContainer::Container_t::const_iterator indexsetiter = container.begin();
+        indexsetiter != container.end(); ++indexsetiter) {
+      const IndexSet::ptr &index = *indexsetiter;
+      // this either generates a new entry or updates the present one, as we obtain ref to value
+      boost::fusion::at_key<MapKey>(keysetresults[index]) =
+          sum_value.getContributionForIndexSet(index);
     }
   }
@@ -89,6 +103,11 @@
   //!> lookup map from job ids to ordering in above vectors
   const std::map< JobId_t, size_t > &MatrixNrLookup;
-  //!> vector of results
-  std::vector<MapType> &results;
+  //!> vector of levelresults
+  std::vector<MapType> &levelresults;
+  typedef std::pair< IndexSet::ptr, MapType > keysetresults_pair_t;
+  //!> typedef for map for keyset and each resulting value
+  typedef std::map<IndexSet::ptr, MapType> keysetresults_t;
+  //!> map for IndexSet and its associated contribution
+  keysetresults_t &keysetresults;
 };
 
Index: src/Fragmentation/Summation/AllLevelSummator.hpp
===================================================================
--- src/Fragmentation/Summation/AllLevelSummator.hpp	(revision 69e065666b610d9348120ce282aabfeb2adc7149)
+++ src/Fragmentation/Summation/AllLevelSummator.hpp	(revision b8f0b250c2143e3d8e7c3b8ef67750ab6eccc8b1)
@@ -38,5 +38,5 @@
    *        to job id and hence to _data.
    * \param _MatrixNrLookup lookup from job id to ordering in above vectors
-   * \param _results vector place results into
+   * \param _levelresults vector place levelresults into
    */
   AllLevelSummator(
@@ -45,12 +45,14 @@
       const IndexSetContainer::Container_t &_container,
       const std::map< JobId_t, size_t > &_MatrixNrLookup,
-      std::vector<MapType> &_results) :
+      std::vector<MapType> &_levelresults,
+      std::map<IndexSet::ptr, MapType> &_keysetresults) :
     subsetmap(_subsetmap),
     data(_data),
     container(_container),
     MatrixNrLookup(_MatrixNrLookup),
-    results(_results)
+    levelresults(_levelresults),
+    keysetresults(_keysetresults)
   {
-    ASSERT( results.size() >= subsetmap->getMaximumSetLevel(),
+    ASSERT( levelresults.size() >= subsetmap->getMaximumSetLevel(),
         "AllLevelSummator() - result vector is not large enough.");
   }
@@ -65,16 +67,28 @@
     // We retrieve the type of the MPQCData member variable from the boost::fusion::map.
     typedef typename boost::fusion::result_of::value_at_key<MapType, MapKey>::type MapValue;
+
     // create Summator instance
     Summator<MapType, MapKey> sum_value(
         subsetmap, data, container, MatrixNrLookup
         );
+
+    // fill levelresults
     const size_t MaxLevel = subsetmap->getMaximumSetLevel();
     for (size_t level=1; level <= MaxLevel; ++level) {
-      MapType &LevelResults = results[level-1];
-      // sum up and store in results
+      MapType &LevelResults = levelresults[level-1];
+      // sum up and store in levelresults
       const MapValue value = sum_value(level);
       boost::fusion::at_key<MapKey>(LevelResults) = value;
       // print value
       //LOG(0, "STATUS: Level " << level << " resulting " << printKeyNames::printName<MapKey>() << " is " << value << ".");
+    }
+
+    // fill keysetresults
+    for (IndexSetContainer::Container_t::const_iterator indexsetiter = container.begin();
+        indexsetiter != container.end(); ++indexsetiter) {
+      const IndexSet::ptr &index = *indexsetiter;
+      // this either generates a new entry or updates the present one, as we obtain ref to value
+      boost::fusion::at_key<MapKey>(keysetresults[index]) =
+          sum_value.getContributionForIndexSet(index);
     }
   }
@@ -89,6 +103,11 @@
   //!> lookup map from job ids to ordering in above vectors
   const std::map< JobId_t, size_t > &MatrixNrLookup;
-  //!> vector of results
-  std::vector<MapType> &results;
+  //!> vector of levelresults
+  std::vector<MapType> &levelresults;
+  typedef std::pair< IndexSet::ptr, MapType > keysetresults_pair_t;
+  //!> typedef for map for keyset and each resulting value
+  typedef std::map<IndexSet::ptr, MapType> keysetresults_t;
+  //!> map for IndexSet and its associated contribution
+  keysetresults_t &keysetresults;
 };
 
Index: src/Fragmentation/Summation/OrthogonalSumUpPerLevel.hpp
===================================================================
--- src/Fragmentation/Summation/OrthogonalSumUpPerLevel.hpp	(revision 69e065666b610d9348120ce282aabfeb2adc7149)
+++ src/Fragmentation/Summation/OrthogonalSumUpPerLevel.hpp	(revision b8f0b250c2143e3d8e7c3b8ef67750ab6eccc8b1)
@@ -21,4 +21,5 @@
 #include "Fragmentation/Converter/DataConverter.hpp"
 #include "Fragmentation/Summation/AllLevelOrthogonalSummator.hpp"
+#include "Fragmentation/Summation/IndexSet.hpp"
 #include "Fragmentation/Summation/IndexSetContainer.hpp"
 
@@ -28,9 +29,11 @@
 
 template <typename TypeMap, typename TypeData, typename TypeVector>
-std::vector<TypeMap> OrthogonalSumUpPerLevel(
+void OrthogonalSumUpPerLevel(
     const std::map<JobId_t, TypeData> &fragmentData,
     const std::map< JobId_t, size_t > &MatrixNrLookup,
     const IndexSetContainer::ptr &container,
-    SubsetMap::ptr &subsetmap
+    SubsetMap::ptr &subsetmap,
+    std::vector<TypeMap> &levelresults,
+    std::map<IndexSet::ptr, TypeMap> &keysetresults
     )
 {
@@ -39,5 +42,5 @@
   convertDataTo<TypeData, TypeMap>(fragmentData, Data_fused);
   // instantiate summator
-  std::vector<TypeMap> Result_fused(subsetmap->getMaximumSetLevel());
+  levelresults.resize(subsetmap->getMaximumSetLevel());
   AllLevelOrthogonalSummator<TypeMap> Summer(
               subsetmap,
@@ -45,8 +48,8 @@
               container->getContainer(),
               MatrixNrLookup,
-              Result_fused);
+              levelresults,
+              keysetresults);
   // sum up for each type key in TypeVector
   boost::mpl::for_each<TypeVector>(boost::ref(Summer));
-  return Result_fused;
 }
 
Index: src/Fragmentation/Summation/SumUpPerLevel.hpp
===================================================================
--- src/Fragmentation/Summation/SumUpPerLevel.hpp	(revision 69e065666b610d9348120ce282aabfeb2adc7149)
+++ src/Fragmentation/Summation/SumUpPerLevel.hpp	(revision b8f0b250c2143e3d8e7c3b8ef67750ab6eccc8b1)
@@ -20,4 +20,5 @@
 #include "Fragmentation/Converter/DataConverter.hpp"
 #include "Fragmentation/Summation/AllLevelSummator.hpp"
+#include "Fragmentation/Summation/IndexSet.hpp"
 #include "Fragmentation/Summation/IndexSetContainer.hpp"
 
@@ -27,9 +28,11 @@
 
 template <typename TypeMap, typename TypeData, typename TypeVector>
-std::vector<TypeMap> SumUpPerLevel(
+void SumUpPerLevel(
     const std::map<JobId_t, TypeData> &fragmentData,
     const std::map< JobId_t, size_t > &MatrixNrLookup,
     const IndexSetContainer::ptr &container,
-    SubsetMap::ptr &subsetmap
+    SubsetMap::ptr &subsetmap,
+    std::vector<TypeMap> &levelresults,
+    std::map<IndexSet::ptr, TypeMap> &keysetresults
     )
 {
@@ -38,5 +41,5 @@
   convertDataTo<TypeData, TypeMap>(fragmentData, Data_fused);
   // instantiate summator
-  std::vector<TypeMap> Result_fused(subsetmap->getMaximumSetLevel());
+  levelresults.resize(subsetmap->getMaximumSetLevel());
   AllLevelSummator<TypeMap> Summer(
               subsetmap,
@@ -44,8 +47,8 @@
               container->getContainer(),
               MatrixNrLookup,
-              Result_fused);
+              levelresults,
+              keysetresults);
   // sum up for each type key in TypeVector
   boost::mpl::for_each<TypeVector>(boost::ref(Summer));
-  return Result_fused;
 }
 
