Index: src/Fragmentation/Automation/FragmentationResults.cpp
===================================================================
--- src/Fragmentation/Automation/FragmentationResults.cpp	(revision 4f056ee4f8f8ba61bbfbf5d3291ade39e1f70347)
+++ src/Fragmentation/Automation/FragmentationResults.cpp	(revision 19c50eb693e8d3faf8263bc25521a1c6c63b67e5)
@@ -51,5 +51,4 @@
 #include "Fragmentation/Summation/AllLevelOrthogonalSummator.hpp"
 #include "Fragmentation/Summation/IndexSetContainer.hpp"
-#include "Fragmentation/Summation/OrthogonalFullSummator.hpp"
 #include "Fragmentation/Summation/OrthogonalSumUpPerLevel.hpp"
 #include "Fragmentation/Summation/SubsetMap.hpp"
@@ -114,6 +113,6 @@
   SubsetMap::ptr subsetmap(new SubsetMap(*container));
 
-  MaxLevel = subsetmap->getMaximumSubsetLevel();
-
+  MaxLevel = subsetmap->getMaximumSetLevel();
+  LOG(1, "INFO: Summing up results till level " << MaxLevel << ".");
   /// convert all MPQCData to MPQCDataMap_t
   {
Index: src/Fragmentation/Summation/AllLevelOrthogonalSummator.hpp
===================================================================
--- src/Fragmentation/Summation/AllLevelOrthogonalSummator.hpp	(revision 4f056ee4f8f8ba61bbfbf5d3291ade39e1f70347)
+++ src/Fragmentation/Summation/AllLevelOrthogonalSummator.hpp	(revision 19c50eb693e8d3faf8263bc25521a1c6c63b67e5)
@@ -52,5 +52,5 @@
     results(_results)
   {
-    ASSERT( results.size() >= subsetmap->getMaximumSubsetLevel(),
+    ASSERT( results.size() >= subsetmap->getMaximumSetLevel(),
         "AllLevelOrthogonalSummator() - result vector is not large enough.");
   }
@@ -69,5 +69,5 @@
         subsetmap, data, container, MatrixNrLookup
         );
-    const size_t MaxLevel = subsetmap->getMaximumSubsetLevel();
+    const size_t MaxLevel = subsetmap->getMaximumSetLevel();
     for (size_t level=1; level <= MaxLevel; ++level) {
       MapType &LevelResults = results[level-1];
Index: src/Fragmentation/Summation/AllLevelSummator.hpp
===================================================================
--- src/Fragmentation/Summation/AllLevelSummator.hpp	(revision 4f056ee4f8f8ba61bbfbf5d3291ade39e1f70347)
+++ src/Fragmentation/Summation/AllLevelSummator.hpp	(revision 19c50eb693e8d3faf8263bc25521a1c6c63b67e5)
@@ -52,5 +52,5 @@
     results(_results)
   {
-    ASSERT( results.size() >= subsetmap->getMaximumSubsetLevel(),
+    ASSERT( results.size() >= subsetmap->getMaximumSetLevel(),
         "AllLevelSummator() - result vector is not large enough.");
   }
@@ -69,5 +69,5 @@
         subsetmap, data, container, MatrixNrLookup
         );
-    const size_t MaxLevel = subsetmap->getMaximumSubsetLevel();
+    const size_t MaxLevel = subsetmap->getMaximumSetLevel();
     for (size_t level=1; level <= MaxLevel; ++level) {
       MapType &LevelResults = results[level-1];
Index: src/Fragmentation/Summation/IndexSetContainer.cpp
===================================================================
--- src/Fragmentation/Summation/IndexSetContainer.cpp	(revision 4f056ee4f8f8ba61bbfbf5d3291ade39e1f70347)
+++ src/Fragmentation/Summation/IndexSetContainer.cpp	(revision 19c50eb693e8d3faf8263bc25521a1c6c63b67e5)
@@ -45,10 +45,8 @@
 #include "Fragmentation/KeySetsContainer.hpp"
 
-IndexSet::ptr IndexSetContainer::AllIndices(new IndexSet);
-
-IndexSet::ptr& IndexSetContainer::createSuperSet(const KeySetsContainer &_keysets) const
+IndexSet::ptr IndexSetContainer::createSuperSet(const KeySetsContainer &_keysets) const
 {
   // create superset
-  //IndexSet::ptr AllIndices(new IndexSet);
+  IndexSet::ptr _AllIndices(new IndexSet);
   for (KeySetsContainer::ArrayOfIntVectors::const_iterator iter = _keysets.KeySets.begin();
       iter != _keysets.KeySets.end(); ++iter)
@@ -56,18 +54,19 @@
         keyiter != (*iter).end(); ++keyiter) {
       if (*keyiter != -1)
-        AllIndices->insert((Index_t)*keyiter);
+        _AllIndices->insert((Index_t)*keyiter);
     }
-  LOG(1, "INFO: AllIndices is " << *AllIndices << ".");
+  LOG(1, "INFO: AllIndices is " << *_AllIndices << ".");
 
-  return AllIndices;
+  return _AllIndices;
 }
 
 IndexSetContainer::IndexSetContainer(const KeySetsContainer &_keysets) :
-  SortedVector<IndexSet>(createSuperSet(_keysets))
+     AllIndices(createSuperSet(_keysets))
 {
-  const size_t SupersetSize = getContainer()[0]->size();
+  const size_t SupersetSize = AllIndices->size();
   // create container with all keysets
   for (KeySetsContainer::ArrayOfIntVectors::const_iterator iter = _keysets.KeySets.begin();
       iter != _keysets.KeySets.end(); ++iter) {
+    // create the IndexSets ...
     IndexSet tempset;
     for(KeySetsContainer::IntVector::const_iterator keyiter = (*iter).begin();
@@ -75,6 +74,9 @@
       if (*keyiter != -1)
         tempset.insert((Index_t)*keyiter);
-    if (tempset.size() < SupersetSize)  // only insert if not super set
+    // ... and insert, making sure that super set is AllIndices when present
+    if (tempset.size() < SupersetSize)
       insert(tempset);
+    else
+      insert(AllIndices);
   }
 }
Index: src/Fragmentation/Summation/IndexSetContainer.hpp
===================================================================
--- src/Fragmentation/Summation/IndexSetContainer.hpp	(revision 4f056ee4f8f8ba61bbfbf5d3291ade39e1f70347)
+++ src/Fragmentation/Summation/IndexSetContainer.hpp	(revision 19c50eb693e8d3faf8263bc25521a1c6c63b67e5)
@@ -83,14 +83,23 @@
   size_t countSetsTillLevel(const size_t level) const;
 
+  /** Getter to the super set.
+   *
+   * @return AllIndices
+   */
+  const IndexSet::ptr getSuperSet() const
+  {
+    return AllIndices;
+  }
+
 private:
-  /** Helper function to get the super set out of a KeySetsContainer.
+  /** Helper function to create the super set out of a KeySetsContainer.
    *
    * @param _keysets keysets to construct super set for
-   * @return IndexSet that contains each index once that appears in the sets of \a _keysets
+   * @return super set created from all keysets in \a _keysets
    */
-  IndexSet::ptr& createSuperSet(const KeySetsContainer &_keysets) const;
+  IndexSet::ptr createSuperSet(const KeySetsContainer &_keysets) const;
 
-  //!> static instance for AllIndices such that createSuperSet may return a reference.
-  static IndexSet::ptr AllIndices;
+  //!> super set that contains all present index sets
+  IndexSet::ptr AllIndices;
 };
 
Index: src/Fragmentation/Summation/Makefile.am
===================================================================
--- src/Fragmentation/Summation/Makefile.am	(revision 4f056ee4f8f8ba61bbfbf5d3291ade39e1f70347)
+++ src/Fragmentation/Summation/Makefile.am	(revision 19c50eb693e8d3faf8263bc25521a1c6c63b67e5)
@@ -13,5 +13,4 @@
 	Fragmentation/Summation/IndexSet.hpp \
 	Fragmentation/Summation/IndexSetContainer.hpp \
-	Fragmentation/Summation/OrthogonalFullSummator.hpp \
 	Fragmentation/Summation/OrthogonalSummation.hpp \
 	Fragmentation/Summation/OrthogonalSummation_impl.hpp \
Index: src/Fragmentation/Summation/OrthogonalFullSummator.hpp
===================================================================
--- src/Fragmentation/Summation/OrthogonalFullSummator.hpp	(revision 4f056ee4f8f8ba61bbfbf5d3291ade39e1f70347)
+++ 	(revision )
@@ -1,141 +1,0 @@
-/*
- * OrthogonalFullSummator.hpp
- *
- *  Created on: 08.09.2012
- *      Author: heber
- */
-
-#ifndef ORTHOGONALFULLSUMMATOR_HPP_
-#define ORTHOGONALFULLSUMMATOR_HPP_
-
-// include config.h
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <boost/fusion/sequence.hpp>
-
-#include "CodePatterns/Assert.hpp"
-
-#include "Fragmentation/Summation/OrthogonalSummation.hpp"
-#include "Fragmentation/Summation/SetValue.hpp"
-#include "Jobs/MPQCDataMap.hpp"
-
-/** OrthogonalFullSummator is a general class for making us of OrthogonalSummation.
- *
- *
- * This class is very similar to OrthogonalSummation only that we specifically include
- * the full set (with a value!) as well. Also there is a function to obtain the
- * contribution. This is intended to check a full calculation against the truncated
- * sum.
- */
-template <typename MapType, typename MapKey>
-struct OrthogonalFullSummator {
-  /** We retrieve the type of the MPQCData member variable from the
-   * boost::fusion::map and stored it in this typedef. Note that for
-   * internal types (e.g. MapValue::const_iterator we need to place
-   * \b typename before).
-   */
-  typedef typename boost::fusion::result_of::value_at_key<MapType, MapKey>::type MapValue;
-
-  /** Constructor for class OrthogonalFullSummator.
-   *
-   * \param _subsetmap map with hierarchy of IndexSet's
-   * \param _data MPQCData converted to MPQCDataMap_t type, associated to job id
-   * \param _container container of IndexSet's such that each set has correct order
-   *        to job id and hence to _data.
-   * \param _MatrixNrLookup lookup from job id to ordering in above vectors
-   */
-  OrthogonalFullSummator(
-      SubsetMap::ptr &_subsetmap,
-      const std::map<JobId_t, MapType> &_data,
-      const IndexSetContainer::Container_t &_container,
-      const std::map< JobId_t, size_t > &_MatrixNrLookup) :
-    indices(getSubsets(_container)),
-    values(createValues(_data, _container, _MatrixNrLookup)),
-    OS(indices, values, _subsetmap)
-  {
-    ASSERT( _data.size() == _container.size(),
-        "OrthogonalFullSummator() - data and indices don't have same size.");
-    ASSERT( _data.size() == _MatrixNrLookup.size(),
-        "OrthogonalFullSummator() - ids and MatrixNrLookup don't have same size.");
-  }
-
-  /** Summation operator.
-   *
-   * Initialises instantiated OrthogonalSummation of the respective type via
-   * \a OrthogonalFullSummator::data, uses OrthogonalSummation::operator() to sum and returns
-   * the result.
-   *
-   * \param level up to which level to sum up
-   * \return result of OrthogonalSummation for given type from MPQCDataMap_t.
-   */
-  MapValue operator()(const size_t level)
-  {
-    // evaluate
-    const MapValue result = OS(level);
-    return result;
-  }
-
-  /** Getter for the remaining contribution of the full set.
-   *
-   * @return contribution of allindices
-   */
-  MapValue getFullContribution() const {
-    typename SetValueMap<MapValue>::const_iterator iter = --OS.getSetValues().end();
-    LOG(2, "DEBUG: Returning Full contribution of level " << iter->first->size() << ".");
-    return iter->second->getContribution();
-  }
-
-private:
-  /** Tiny helper to create the indices from a given IndexSetContainer.
-   *
-   * @param container container with IndexSet
-   * @return all subsets contained in \a container
-   */
-  typename OrthogonalSummation<MapValue>::InputSets_t getSubsets(
-      const IndexSetContainer::Container_t &container)
-  {
-    typename OrthogonalSummation<MapValue>::InputSets_t indices(
-        container.begin(),
-        container.end());
-    return indices;
-  }
-
-  /** Tiny helper to create the values for the summation in the correct order.
-   *
-   * @param data
-   * @param container
-   * @param MatrixNrLookup
-   * @return
-   */
-  typename OrthogonalSummation<MapValue>::InputValues_t createValues(
-      const std::map<JobId_t, MapType> &data,
-      const IndexSetContainer::Container_t &container,
-      const std::map< JobId_t, size_t > &MatrixNrLookup)
-  {
-    typename OrthogonalSummation<MapValue>::InputValues_t values(container.size());
-    for (typename std::map<JobId_t, MapType>::const_iterator dataiter = data.begin();
-        dataiter != data.end(); ++dataiter) {
-      const MapType &Data = dataiter->second;
-      const JobId_t &jobid = dataiter->first;
-      const MapValue &value = boost::fusion::at_key<MapKey>(Data);
-      const std::map< JobId_t, size_t >::const_iterator nriter = MatrixNrLookup.find(jobid);
-      ASSERT( nriter != MatrixNrLookup.end(),
-          "OrthogonalFullSummation<>::createValues() - MatrixNrLookup does not contain id "
-          +toString(jobid)+".");
-      values[ nriter->second ] = value;
-    }
-    return values;
-  }
-private:
-  //!> created indices for OS such that we may hand over refs
-  typename OrthogonalSummation<MapValue>::InputSets_t indices;
-  //!> created values for OS such that we may hand over refs
-  typename OrthogonalSummation<MapValue>::InputValues_t values;
-  //!> Summation instance to use in operator()(level)
-  OrthogonalSummation<MapValue> OS;
-};
-
-
-#endif /* ORTHOGONALFULLSUMMATOR_HPP_ */
Index: src/Fragmentation/Summation/OrthogonalSumUpPerLevel.hpp
===================================================================
--- src/Fragmentation/Summation/OrthogonalSumUpPerLevel.hpp	(revision 4f056ee4f8f8ba61bbfbf5d3291ade39e1f70347)
+++ src/Fragmentation/Summation/OrthogonalSumUpPerLevel.hpp	(revision 19c50eb693e8d3faf8263bc25521a1c6c63b67e5)
@@ -39,5 +39,5 @@
   convertDataTo<TypeData, TypeMap>(fragmentData, Data_fused);
   // instantiate summator
-  std::vector<TypeMap> Result_fused(subsetmap->getMaximumSubsetLevel());
+  std::vector<TypeMap> Result_fused(subsetmap->getMaximumSetLevel());
   AllLevelOrthogonalSummator<TypeMap> Summer(
               subsetmap,
Index: src/Fragmentation/Summation/SortedVector.hpp
===================================================================
--- src/Fragmentation/Summation/SortedVector.hpp	(revision 4f056ee4f8f8ba61bbfbf5d3291ade39e1f70347)
+++ src/Fragmentation/Summation/SortedVector.hpp	(revision 19c50eb693e8d3faf8263bc25521a1c6c63b67e5)
@@ -84,4 +84,14 @@
   }
 
+  /** Default constructor.
+   *
+   * An empty vector is automatically sorted.
+   *
+   * @return
+   */
+  SortedVector() :
+    ContainerSorted(true)
+  {}
+
   /** Getter to sorted container.
    *
Index: src/Fragmentation/Summation/SubsetMap.cpp
===================================================================
--- src/Fragmentation/Summation/SubsetMap.cpp	(revision 4f056ee4f8f8ba61bbfbf5d3291ade39e1f70347)
+++ src/Fragmentation/Summation/SubsetMap.cpp	(revision 19c50eb693e8d3faf8263bc25521a1c6c63b67e5)
@@ -40,8 +40,10 @@
 #include <boost/bind.hpp>
 #include <boost/foreach.hpp>
+#include <boost/lambda/lambda.hpp>
 #include <algorithm>
 #include <bitset>
 #include <set>
 
+#include "CodePatterns/Assert.hpp"
 #include "CodePatterns/Log.hpp"
 
@@ -49,35 +51,27 @@
   tempset(new IndexSet())
 {
+  /// go through all IndexSets
   const IndexSetContainer::Container_t &container = _container.getContainer();
-
-// we don't need this level-wise sorting as this is automatically achieved by specific sorting
-//  /// place in level-wise multimap
-//  typedef size_t level_t;
-//  // note: We use an IndexSetContainer as it is not accessed while filling it
-//  // also, as insert uses push_back, the IndexSetContainer is actually created
-//  // as sorted. Hence, the call to sort() just needs linear time (and does
-//  // nothing)
-//  typedef std::map<level_t, IndexSetContainer > IndexSetPerLevel_t;
-//  IndexSetPerLevel_t IndexSetPerLevel;
-//  for(IndexSetContainer::Container_t::const_iterator iter = container.begin();
-//      iter != container.end(); ++iter) {
-//    // key present in map?
-//    const size_t level = (*iter)->size();
-//    LOG(1, "INFO: Current set is " << **iter << " with size " << level << ".");
-//    IndexSetPerLevel_t::iterator leveliter = IndexSetPerLevel.find(level);
-//    // we have to explicitly copy the shared_ptr for insertion due to const container
-//    IndexSet_ptr ptr(*iter);
-//    if (leveliter == IndexSetPerLevel.end()) {
-//      LOG(2, "DEBUG: Level not present in Lookup, creating new container");
-//      IndexSetPerLevel.insert( std::make_pair( level, IndexSetContainer(ptr)) );
-//    } else {
-//      LOG(2, "DEBUG: Level present in Lookup, appending to container");
-//      leveliter->second.insert(ptr);
-//    }
-//  }
-
-  /// go through all IndexSets
-  std::for_each( container.begin(), container.end(),
-      boost::bind(&SubsetMap::gatherSubsets, this, _1));
+  for (IndexSetContainer::Container_t::const_iterator iter = container.begin();
+      iter != container.end(); ++iter) {
+    // check whether its the super set
+    if (*iter == _container.getSuperSet()) {
+      // place all other sets as its subsets
+      std::vector<IndexSet> returnsets;
+      returnsets.reserve(container.size());
+      for (IndexSetContainer::Container_t::const_iterator insertiter = container.begin();
+            insertiter != container.end(); ++insertiter)
+        if (iter != insertiter) {
+          LOG(2, "INFO: Current subset is " << **insertiter << " for super set.");
+          ASSERT( _container.getSuperSet()->contains(**insertiter),
+              "SubsetMap::SubsetMap() - "+toString(**insertiter)+" is not contained in super set "
+              +toString(*_container.getSuperSet())+".");
+          returnsets.push_back(**insertiter);
+        }
+      Lookup.insert( std::make_pair(*iter, IndexSetContainer::ptr(new IndexSetContainer(returnsets))) );
+    } else {
+      gatherSubsets(*iter);
+    }
+  }
 }
 
@@ -184,12 +178,4 @@
 }
 
-size_t SubsetMap::getMaximumSubsetLevel() const
-{
-  // last one is super set, hence, the one before has largest subset size
-  Lookup_t::const_iterator iter = --Lookup.end();
-  --iter;
-  return iter->first->size();
-}
-
 size_t SubsetMap::getMaximumSetLevel() const
 {
Index: src/Fragmentation/Summation/SubsetMap.hpp
===================================================================
--- src/Fragmentation/Summation/SubsetMap.hpp	(revision 4f056ee4f8f8ba61bbfbf5d3291ade39e1f70347)
+++ src/Fragmentation/Summation/SubsetMap.hpp	(revision 19c50eb693e8d3faf8263bc25521a1c6c63b67e5)
@@ -58,13 +58,4 @@
     return lookupiter->second;
   }
-
-  /** Returns the size of the largest \b sub set.
-   *
-   * This would be \f${\cal O}(n)\f$ if we had to look at each set. However, due
-   * to the specific sorting we just have to check the last sets.
-   *
-   * @return number of indices in largest subset, -1 if SubsetMap contains no IndexSet's
-   */
-  size_t getMaximumSubsetLevel() const;
 
   /** Returns the size of the largest set.
Index: src/Fragmentation/Summation/SumUpPerLevel.hpp
===================================================================
--- src/Fragmentation/Summation/SumUpPerLevel.hpp	(revision 4f056ee4f8f8ba61bbfbf5d3291ade39e1f70347)
+++ src/Fragmentation/Summation/SumUpPerLevel.hpp	(revision 19c50eb693e8d3faf8263bc25521a1c6c63b67e5)
@@ -38,5 +38,5 @@
   convertDataTo<TypeData, TypeMap>(fragmentData, Data_fused);
   // instantiate summator
-  std::vector<TypeMap> Result_fused(subsetmap->getMaximumSubsetLevel());
+  std::vector<TypeMap> Result_fused(subsetmap->getMaximumSetLevel());
   AllLevelSummator<TypeMap> Summer(
               subsetmap,
Index: src/Fragmentation/Summation/unittests/SubsetMapUnitTest.cpp
===================================================================
--- src/Fragmentation/Summation/unittests/SubsetMapUnitTest.cpp	(revision 4f056ee4f8f8ba61bbfbf5d3291ade39e1f70347)
+++ src/Fragmentation/Summation/unittests/SubsetMapUnitTest.cpp	(revision 19c50eb693e8d3faf8263bc25521a1c6c63b67e5)
@@ -301,7 +301,7 @@
 }
 
-/** UnitTest for getMaximumSubsetLevel()
- */
-void SubsetMapTest::getMaximumSubsetLevelTest()
+/** UnitTest for getMaximumSetLevel()
+ */
+void SubsetMapTest::getMaximumSetLevelTest()
 {
   // create small container
@@ -323,7 +323,7 @@
     CPPUNIT_ASSERT( SM != NULL );
 
-    CPPUNIT_ASSERT_EQUAL( (size_t)1, SM->getMaximumSubsetLevel() );
-    // we are strictly less than super set (last one)
-    CPPUNIT_ASSERT( SM->getMaximumSubsetLevel() < (--SM->Lookup.end())->first->size() );
+    CPPUNIT_ASSERT_EQUAL( (size_t)2, SM->getMaximumSetLevel() );
+    // we are strictly the last set
+    CPPUNIT_ASSERT( SM->getMaximumSetLevel() == (--SM->Lookup.end())->first->size() );
   }
 
@@ -335,6 +335,6 @@
     CPPUNIT_ASSERT( SM != NULL );
 
-    CPPUNIT_ASSERT_EQUAL( (size_t)3, SM->getMaximumSubsetLevel() );
-    CPPUNIT_ASSERT( SM->getMaximumSubsetLevel() < (--SM->Lookup.end())->first->size() );
+    CPPUNIT_ASSERT_EQUAL( (size_t)4, SM->getMaximumSetLevel() );
+    CPPUNIT_ASSERT( SM->getMaximumSetLevel() == (--SM->Lookup.end())->first->size() );
   }
 }
Index: src/Fragmentation/Summation/unittests/SubsetMapUnitTest.hpp
===================================================================
--- src/Fragmentation/Summation/unittests/SubsetMapUnitTest.hpp	(revision 4f056ee4f8f8ba61bbfbf5d3291ade39e1f70347)
+++ src/Fragmentation/Summation/unittests/SubsetMapUnitTest.hpp	(revision 19c50eb693e8d3faf8263bc25521a1c6c63b67e5)
@@ -31,5 +31,5 @@
     CPPUNIT_TEST ( getSubsetTest );
     CPPUNIT_TEST ( gatherSubsetTest );
-    CPPUNIT_TEST ( getMaximumSubsetLevelTest );
+    CPPUNIT_TEST ( getMaximumSetLevelTest );
     CPPUNIT_TEST_SUITE_END();
 
@@ -41,5 +41,5 @@
       void getSubsetTest();
       void gatherSubsetTest();
-      void getMaximumSubsetLevelTest();
+      void getMaximumSetLevelTest();
 
 private:
