diff --git a/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp b/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp
index 06096a9960aab2b13c694492b2eb1d022a6d9728..63b9bba20d1575cc3377109b856d57a09bc4aae8 100644
--- a/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp
+++ b/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp
@@ -286,7 +286,10 @@ namespace armarx::armem::server
 
             // append result to return memory and sanity check
             wmResult.append(ltmResult);
-            ARMARX_CHECK(not wmResult.empty());
+            if (wmResult.empty())
+            {
+                ARMARX_ERROR << "A merged Memory has no data although at least the LTM result contains data. This indicates that something is wrong.";
+            }
 
             // Ist das wirklich notwendig?
             // query again to limit output size (TODO: Skip if querytype is all)
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/Converter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/Converter.h
index 0ed3d9b08188179d17e5baaf0087b0c33e75eaa0..c42e9c0d57d64f4776f7c1f586ea3eba3a4af75a 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/Converter.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/Converter.h
@@ -26,7 +26,7 @@ namespace armarx::armem::server::ltm
         virtual ~Converter() = default;
 
         virtual std::pair<std::vector<unsigned char>, std::string> convert(const aron::data::VariantPtr& data) = 0;
-        virtual aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) = 0;
+        virtual aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const std::string&) = 0;
 
     public:
         const ConverterType type;
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.cpp
index 30349fd4faa55ab513d6c080251138cb16bafe77..39b4d94b015841467ccadf14e34bf6ab1bf00ef0 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.cpp
@@ -9,9 +9,9 @@ namespace armarx::armem::server::ltm
         return _convert(d);
     }
 
-    aron::data::VariantPtr ImageConverter::convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string& m)
+    aron::data::VariantPtr ImageConverter::convert(const std::vector<unsigned char>& data, const std::string& m)
     {
-        auto d = _convert(data, p, m);
+        auto d = _convert(data, m);
         return d;
     }
 
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.h
index 440c1c6c50815eb56576fca2cd1bb65d1185f0ec..8cb070f09d46f4f7ce4bc069920f082c30ba1763 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.h
@@ -21,10 +21,10 @@ namespace armarx::armem::server::ltm
         virtual ~ImageConverter() = default;
 
         std::pair<std::vector<unsigned char>, std::string> convert(const aron::data::VariantPtr& data) final;
-        aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
+        aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const std::string&) final;
 
     protected:
         virtual std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::NDArrayPtr& data) = 0;
-        virtual aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) = 0;
+        virtual aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const std::string&) = 0;
     };
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.cpp
index 6bf18cff45eea27f018c9dc7c371becbb5baf90a..c5eee777b60ac5b7e1c97606e5902107afdb0221 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.cpp
@@ -25,9 +25,9 @@ namespace armarx::armem::server::ltm::converter::image
         return std::make_pair(buffer, "");
     }
 
-    aron::data::NDArrayPtr ExrConverter::_convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string& m)
+    aron::data::NDArrayPtr ExrConverter::_convert(const std::vector<unsigned char>& data, const std::string& m)
     {
         cv::Mat img = cv::imdecode(data, cv::IMREAD_ANYDEPTH);
-        return aron::converter::AronOpenCVConverter::ConvertFromMat(img, p);
+        return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
     }
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.h
index 07e94a5b2c8ef2951949854600e25f4a901d6478..ad4b1bfa2f4b517a55136ace72942d4440404c9f 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.h
@@ -16,6 +16,6 @@ namespace armarx::armem::server::ltm::converter::image
 
     protected:
         std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::NDArrayPtr& data) final;
-        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
+        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
     };
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.cpp
index 03453e6f6c4432e1efd0445ae393d1d14242a4bd..e8536cf64841d23712e7264ce76282039b893189 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.cpp
@@ -39,23 +39,23 @@ namespace armarx::armem::server::ltm::converter::image
         return std::make_pair(buffer, "");
     }
 
-    aron::data::NDArrayPtr PngConverter::_convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string& m)
+    aron::data::NDArrayPtr PngConverter::_convert(const std::vector<unsigned char>& data, const std::string& m)
     {
         if (m == ".rgb")
         {
             cv::Mat img = cv::imdecode(data, cv::IMREAD_COLOR);
             cv::cvtColor(img, img, CV_BGR2RGB);
-            return aron::converter::AronOpenCVConverter::ConvertFromMat(img, p);
+            return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
         }
 
         if (m == ".gs")
         {
             cv::Mat img = cv::imdecode(data, cv::IMREAD_GRAYSCALE);
-            return aron::converter::AronOpenCVConverter::ConvertFromMat(img, p);
+            return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
         }
 
         // try to load without conversion
         cv::Mat img = cv::imdecode(data, cv::IMREAD_ANYCOLOR);
-        return aron::converter::AronOpenCVConverter::ConvertFromMat(img, p);
+        return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
     }
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.h
index 0c443fa794d22a6a7a6f5c837565693f8cf2e28c..5b6c80134319a52b77565dba322349985fed2267 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.h
@@ -16,6 +16,6 @@ namespace armarx::armem::server::ltm::converter::image
 
     protected:
         std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::NDArrayPtr& data) final;
-        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
+        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
     };
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.cpp
index e6c3345028e9c3af35636d0f509412c4e8ca925a..4f0808a6f03f1739e76cf6fc02a9a155be334be8 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.cpp
@@ -9,9 +9,9 @@ namespace armarx::armem::server::ltm
         return _convert(d);
     }
 
-    aron::data::VariantPtr ObjectConverter::convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string& m)
+    aron::data::VariantPtr ObjectConverter::convert(const std::vector<unsigned char>& data, const std::string& m)
     {
-        auto d = _convert(data, p, m);
+        auto d = _convert(data, m);
         return d;
     }
 
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.h
index 113dd7a5b726f9b75efa07875f0a07fa443fc3a1..35f1a9d968221565184a823e3e57a20d83565546 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.h
@@ -21,10 +21,10 @@ namespace armarx::armem::server::ltm
         virtual ~ObjectConverter() = default;
 
         std::pair<std::vector<unsigned char>, std::string> convert(const aron::data::VariantPtr& data) final;
-        aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
+        aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const std::string&) final;
 
     protected:
         virtual std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::DictPtr& data) = 0;
-        virtual aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) = 0;
+        virtual aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const std::string&) = 0;
     };
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.cpp
index 4155808d3c7dc5818bfb48112a6e77f41a74b681..8465201f3bd078b7bd93bec2cbd26378dfd119ab 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.cpp
@@ -24,13 +24,13 @@ namespace armarx::armem::server::ltm::converter::object
         return std::make_pair(bson, str);
     }
 
-    aron::data::DictPtr BsonConverter::_convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string& m)
+    aron::data::DictPtr BsonConverter::_convert(const std::vector<unsigned char>& data, const std::string& m)
     {
         bsoncxx::document::view view(data.data(), data.size());
         nlohmann::json json = bsoncxx::to_json(view);
         std::string str = json.dump(2);
         std::vector<unsigned char> jsonVec(str.begin(), str.end());
-        auto v = jsonConverter.convert(jsonVec, p, m);
+        auto v = jsonConverter.convert(jsonVec, m);
         return aron::data::Dict::DynamicCast(v);
     }
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.h
index fddf6870f2bbcbc6580e1eb8bf8907e40416e3a0..6eb183be2c5998a3eb43251ff7018a6e336260ea 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.h
@@ -20,7 +20,7 @@ namespace armarx::armem::server::ltm::converter::object
 
     protected:
         std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::DictPtr& data) final;
-        aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
+        aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
 
     private:
         JsonConverter jsonConverter;
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.cpp
index c24125140309ee7c3c597fbd2a57eba5fff4caaa..1495b275baa88a14aecb9487db781ac0236b57d5 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.cpp
@@ -12,10 +12,10 @@ namespace armarx::armem::server::ltm::converter::object
         return std::make_pair(std::vector<unsigned char>(str.begin(), str.end()), "");
     }
 
-    aron::data::DictPtr JsonConverter::_convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&)
+    aron::data::DictPtr JsonConverter::_convert(const std::vector<unsigned char>& data, const std::string&)
     {
         std::string str(data.begin(), data.end());
         nlohmann::json j = nlohmann::json::parse(str);
-        return aron::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(j, p);
+        return aron::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(j);
     }
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.h
index 0c6d71d119396ff7e0293ea5196c252c9ba3cc7c..1b9f86ee93cda46983201be6e7910e4596734b3e 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.h
@@ -19,6 +19,6 @@ namespace armarx::armem::server::ltm::converter::object
 
     protected:
         std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::DictPtr& data) final;
-        aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
+        aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
     };
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp
index a6a7aa48e28f697254755e857df6c7c70ceb01e3..cfc859a5f89418247c1d7f383cfea1b5bce8aa2a 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp
@@ -8,7 +8,7 @@
 
 namespace armarx::armem::server::ltm::disk
 {
-    CoreSegment::CoreSegment(const std::filesystem::path& p, const MemoryID& id /* UNESCAPED */, const std::shared_ptr<Processors>& filters, const DiskMemoryItem::MemoryEncodingMode mode, const unsigned long e) :
+    CoreSegment::CoreSegment(const std::filesystem::path& p, const MemoryID& id, const std::shared_ptr<Processors>& filters, const DiskMemoryItem::MemoryEncodingMode mode, const unsigned long e) :
         CoreSegmentBase(id, filters),
         DiskMemoryItem(p, EscapeSegmentName(id.memoryName), std::filesystem::path(EscapeSegmentName(id.coreSegmentName))),
         currentMode(mode),
@@ -20,7 +20,6 @@ namespace armarx::armem::server::ltm::disk
     {
         auto mPath = getMemoryBasePathForMode(currentMode, currentExport);
         auto relPath = getRelativePathForMode(currentMode);
-
         if (!util::checkIfBasePathExists(mPath) || !util::checkIfFolderExists(mPath, relPath))
         {
             return false;
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp
index ea5ad1757f2d71e955d41a80a416a2c10474feb7..8b00d8d39b8fa49de6c31d8b617549d97e6a45cb 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp
@@ -67,7 +67,6 @@ namespace armarx::armem::server::ltm::disk
                         continue;
                     }
 
-
                     EntitySnapshot c(memoryParentPath, id().withTimestamp(timeFromStringMicroSeconds(usecName)), processors, currentMode, currentExport);
                     func(c);
                 }
@@ -78,7 +77,7 @@ namespace armarx::armem::server::ltm::disk
 
     bool Entity::forEachSnapshotInIndexRange(long first, long last, std::function<void(EntitySnapshot&)> func) const
     {
-        //ARMARX_WARNING << "PLEASE NOTE THAT QUERYING THE LTM INDEX WISE MAY BE BUGGY BECAUSE THE FILESYSTEM ITERATOR IS UNSORTED!";
+        ARMARX_WARNING << "PLEASE NOTE THAT QUERYING THE LTM INDEX WISE MAY BE BUGGY BECAUSE THE FILESYSTEM ITERATOR IS UNSORTED!";
 
         if (first < 0 or last < 0)
         {
@@ -97,11 +96,11 @@ namespace armarx::armem::server::ltm::disk
         long checked = 0;
         auto f = [&](EntitySnapshot& e)
         {
+            checked++;
             if (checked >= first && checked <= last)
             {
                 func(e);
             }
-            checked++;
         };
 
         return forEachSnapshot(std::move(f));
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.cpp
index aea0141b662e58a1dda66b261ccec875bcdf0768..f1706a545a0f3d81cee3637e3bef3f5eb7df0e17 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.cpp
@@ -12,7 +12,7 @@
 
 namespace armarx::armem::server::ltm::disk
 {
-    EntitySnapshot::EntitySnapshot(const std::filesystem::path& p, const MemoryID& id /* UNESCAPED */, const std::shared_ptr<Processors>& filters, const DiskMemoryItem::MemoryEncodingMode mode, const unsigned long e) :
+    EntitySnapshot::EntitySnapshot(const std::filesystem::path& p, const MemoryID& id, const std::shared_ptr<Processors>& filters, const DiskMemoryItem::MemoryEncodingMode mode, const unsigned long e) :
         EntitySnapshotBase(id, filters),
         DiskMemoryItem(p, EscapeSegmentName(id.memoryName),
                        std::filesystem::path(EscapeSegmentName(id.coreSegmentName))
@@ -29,7 +29,6 @@ namespace armarx::armem::server::ltm::disk
     {
         auto mPath = getMemoryBasePathForMode(currentMode, currentExport);
         auto relPath = getRelativePathForMode(currentMode);
-
         if (!util::checkIfBasePathExists(mPath) || !util::checkIfFolderExists(mPath, relPath))
         {
             return;
@@ -83,10 +82,10 @@ namespace armarx::armem::server::ltm::disk
                 {
                     //ARMARX_INFO << "Convert data for entity " << id();
                     auto datafilecontent = util::readDataFromFile(mPath, relDataPath);
-                    auto dataaron = dictConverter.convert(datafilecontent, {}, "");
+                    auto dataaron = dictConverter.convert(datafilecontent, "");
                     datadict = aron::data::Dict::DynamicCastAndCheck(dataaron);
 
-                    // check for special members TODO: only allowed for direct children?
+                    // check for special members
                     for (const auto& [key, m] : datadict->getElements())
                     {
                         for (auto& [t, f] : processors->converters)
@@ -99,7 +98,7 @@ namespace armarx::armem::server::ltm::disk
                                     std::string mode = simox::alg::remove_suffix(simox::alg::remove_prefix(filename, key), f->suffix);
 
                                     auto memberfilecontent = util::readDataFromFile(mPath, relMemberPath);
-                                    auto memberaron = f->convert(memberfilecontent, armarx::aron::Path(datadict->getPath(), std::vector<std::string>{key}), mode);
+                                    auto memberaron = f->convert(memberfilecontent, mode);
                                     datadict->setElement(key, memberaron);
                                     break;
                                 }
@@ -116,7 +115,7 @@ namespace armarx::armem::server::ltm::disk
                 if (std::find(allFilesInIndexFolder.begin(), allFilesInIndexFolder.end(), metadataFilename) != allFilesInIndexFolder.end())
                 {
                     auto metadatafilecontent = util::readDataFromFile(mPath, relMetadataPath);
-                    auto metadataaron = dictConverter.convert(metadatafilecontent, {}, "");
+                    auto metadataaron = dictConverter.convert(metadatafilecontent, "");
                     metadatadict = aron::data::Dict::DynamicCastAndCheck(metadataaron);
                 }
                 else
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.cpp
index 31f5bd8106a32172540db9692b166cdd7fb9d858..a2a374c6de24e4fd1dca370149841d79f85de027 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.cpp
@@ -71,7 +71,6 @@ namespace armarx::armem::server::ltm::disk
         {
             MemoryEncodingMode mode = i == 0 ? MemoryEncodingMode::FILESYSTEM : defaultExportEncodingMode;
             auto mPath = getMemoryBasePathForMode(mode, i);
-
             if (util::checkIfBasePathExists(mPath))
             {
                 for (const auto& subdirName : util::getAllDirectories(mPath, getRelativePathForMode(mode)))
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.cpp
index 631461f464f25977fddbb518c9332bc51e273ce9..32500f7d6a799f678d5fdf1fce09024d93c4a796 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.cpp
@@ -10,7 +10,7 @@
 
 namespace armarx::armem::server::ltm::disk
 {
-    ProviderSegment::ProviderSegment(const std::filesystem::path& p, const MemoryID& id /* UNESCAPED */, const std::shared_ptr<Processors>& filters, const DiskMemoryItem::MemoryEncodingMode mode, const unsigned long e) :
+    ProviderSegment::ProviderSegment(const std::filesystem::path& p, const MemoryID& id, const std::shared_ptr<Processors>& filters, const DiskMemoryItem::MemoryEncodingMode mode, const unsigned long e) :
         ProviderSegmentBase(id, filters),
         DiskMemoryItem(p, EscapeSegmentName(id.memoryName), std::filesystem::path(EscapeSegmentName(id.coreSegmentName)) / EscapeSegmentName(id.providerSegmentName)),
         currentMode(mode),
@@ -22,7 +22,6 @@ namespace armarx::armem::server::ltm::disk
     {
         auto mPath = getMemoryBasePathForMode(currentMode, currentExport);
         auto relPath = getRelativePathForMode(currentMode);
-
         if (!util::checkIfBasePathExists(mPath) || !util::checkIfFolderExists(mPath, relPath))
         {
             return false;
@@ -31,7 +30,7 @@ namespace armarx::armem::server::ltm::disk
         for (const auto& subdirName : util::getAllDirectories(mPath, relPath))
         {
             std::string segmentName = UnescapeSegmentName(subdirName);
-            Entity c(memoryParentPath, id().withEntityName(segmentName), processors, currentMode, currentExport);
+            Entity c(memoryParentPath, id().withEntityName(subdirName), processors, currentMode, currentExport);
             func(c);
         }
         return true;
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.h
index 70250e824baba3192db3c1ee009f6ef3b75f51bc..d9f64fc7a42508ddf297490d4ce8481a054fdb9a 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.h
@@ -2,8 +2,6 @@
 
 #include "../../base/EntityQueryProcessorBase.h"
 
-#include <ArmarXCore/core/logging/Logging.h>
-
 
 namespace armarx::armem::server::query_proc::ltm::detail
 {
diff --git a/source/RobotAPI/libraries/aron/converter/common/VectorConverter.h b/source/RobotAPI/libraries/aron/converter/common/VectorConverter.h
index 14b3ffc96765308ddc49fb684e69fb78b3fa5b5f..096e4830c37276c492d805515e47dd863301f545 100644
--- a/source/RobotAPI/libraries/aron/converter/common/VectorConverter.h
+++ b/source/RobotAPI/libraries/aron/converter/common/VectorConverter.h
@@ -37,97 +37,37 @@ namespace armarx::aron::converter
 {
     class AronVectorConverter
     {
-    private:
-        template<typename T>
-        static std::vector<T> convert_to_1d_vector(const unsigned char* data, const int elements, const int offset, const int size)
-        {
-            ARMARX_CHECK_NOT_NULL(data);
-            ARMARX_CHECK(elements * sizeof(T) == size);
-
-            std::vector<T> v(elements);
-            memcpy(v.data(), data, size);
-
-            return v;
-        }
-
     public:
         AronVectorConverter() = delete;
 
         template<typename T>
-        static std::vector<std::vector<T>> ConvertTo2DVector(const data::NDArray& nav)
-        {
-            const auto& dims = nav.getShape();
-
-            if (dims.size() != 3)
-            {
-                throw error::AronException(__PRETTY_FUNCTION__, "The NDArray must have 3 dimensions.", nav.getPath());
-            }
-
-            if (dims.at(dims.size()-1) != sizeof(T))
-            {
-                throw error::AronException(__PRETTY_FUNCTION__, "Last dimension of the array has to match the element size.", nav.getPath());
-            }
-
-            const int one_row_size = dims.at(1) * dims.at(2);
-            std::vector<std::vector<T>> v(dims.at(0));
-            for (int i = 0; i < dims.at(0); i++)
-            {
-                v[i] = convert_to_1d_vector<T>(nav.getData(), dims.at(1), i * one_row_size, one_row_size);
-            }
-
-            return v;
-        }
-
-        template<typename T>
-        static std::vector<std::vector<T>> ConvertTo2DVector(const data::NDArrayPtr& nav)
+        static std::vector<T> ConvertToVector(const data::NDArrayPtr& nav)
         {
             ARMARX_CHECK_NOT_NULL(nav);
 
-            return ConvertTo2DVector<T>(*nav);
-        }
-
-        template<typename T>
-        static std::vector<T> ConvertTo1DVector(const data::NDArray& nav, const bool allowFlatten = false)
-        {
-            const auto& dims = nav.getShape();
+            const auto& dims = nav->getShape();
 
-            if (!allowFlatten && dims.size() != 2)
+            if (dims.size() != 2)
             {
-                throw error::AronException(__PRETTY_FUNCTION__, "The NDArray must have 2 dimensions.", nav.getPath());
+                throw error::AronException(__PRETTY_FUNCTION__, "The NDArray must have two dimensions.", nav->getPath());
             }
 
-            if (dims.at(dims.size()-1) != sizeof(T))
+            if (dims.at(1) != sizeof(T))
             {
-                throw error::AronException(__PRETTY_FUNCTION__, "Last dimension of the array has to match the element size.", nav.getPath());
+                throw error::AronException(__PRETTY_FUNCTION__, "Dimension 1 of the array has to match the element size.", nav->getPath());
             }
 
-            ARMARX_CHECK(dims.size() >= 1);
+            const int size = std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<>());
 
-            const int elements = std::accumulate(std::begin(dims), std::prev(std::end(dims)), 1, std::multiplies<>());
-            const int all_size = std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<>());
-            std::vector<T> v = convert_to_1d_vector<T>(nav.getData(), elements, 0, all_size);
-            return v;
-        }
+            std::vector<T> v(dims.at(0));
+            memcpy(v.data(), nav->getData(), size);
 
-        template<typename T>
-        static std::vector<T> ConvertTo1DVector(const data::NDArrayPtr& nav, const bool allowFlatten = false)
-        {
-            ARMARX_CHECK_NOT_NULL(nav);
-
-            return ConvertTo1DVector<T>(*nav, allowFlatten);
-        }
-
-        // alias
-        template<typename T>
-        static std::vector<T> ConvertToVector(const data::NDArrayPtr& nav, const bool allowFlatten = false)
-        {
-            return ConvertTo1DVector<T>(nav, allowFlatten);
+            return v;
         }
 
 
-        // Attention: If a vector was flattened, the reconstruction is flattened as well!
         template<typename T>
-        static data::NDArrayPtr ConvertFrom1DVector(const std::vector<T>& data)
+        static data::NDArrayPtr ConvertFromVector(const std::vector<T>& data)
         {
             data::NDArrayPtr ndArr(new data::NDArray);
 
@@ -137,13 +77,6 @@ namespace armarx::aron::converter
             return ndArr;
         }
 
-        // alias
-        template<typename T>
-        static data::NDArrayPtr ConvertFromVector(const std::vector<T>& data)
-        {
-            return ConvertFrom1DVector<T>(data);
-        }
-
     };
 
 }  // namespace armarx::aron::converter
diff --git a/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.cpp b/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.cpp
index e083d47104d5c4747470d97b162028d7fee5a3a7..3729e90a5812a192c256f2deaaa13bbecad71bab 100644
--- a/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.cpp
+++ b/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.cpp
@@ -28,19 +28,18 @@ namespace armarx::aron::converter
         j = aron::type::readAndWrite<type::FromVariantConverter<type::writer::NlohmannJSONWriter>>(aron);
     }
 
-    data::DictPtr AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(const nlohmann::json& j, const armarx::aron::Path& p)
+    data::DictPtr AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(const nlohmann::json& j)
     {
         // TODO Switch case over json type and add other methods, e.g. for float, array, ...
         // TODO add check if json is object_t
-        data::VariantPtr aron = std::make_shared<aron::data::Dict>(p);
+        data::VariantPtr aron = std::make_shared<aron::data::Dict>();
         ConvertFromNlohmannJSON(aron, j);
         return data::Dict::DynamicCastAndCheck(aron);
     }
 
-    type::ObjectPtr AronNlohmannJSONConverter::ConvertFromNlohmannJSONTypeObject(const nlohmann::json& j, const armarx::aron::Path& p)
+    type::ObjectPtr AronNlohmannJSONConverter::ConvertFromNlohmannJSONTypeObject(const nlohmann::json& j)
     {
-        type::ObjectPtr foo = std::make_shared<aron::type::Object>("foo"); // foo is just a placeholder
-        type::VariantPtr aron = std::make_shared<aron::type::Object>(*foo, p);
+        type::VariantPtr aron = std::make_shared<aron::type::Object>("foo"); // foo is just a placeholder
         ConvertFromNlohmannJSON(aron, j);
         return type::Object::DynamicCastAndCheck(aron);
     }
diff --git a/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h b/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h
index 0902ed0c3c133fcec75e0cf2502801f8fcce218a..6cce4d7e363795f6a70184faf4fd60110516590f 100644
--- a/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h
+++ b/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h
@@ -38,10 +38,10 @@ namespace armarx::aron::converter
         static nlohmann::json ConvertToNlohmannJSON(const type::VariantPtr&);
         static void ConvertToNlohmannJSON(const type::VariantPtr&, nlohmann::json&);
 
-        static data::DictPtr ConvertFromNlohmannJSONObject(const nlohmann::json&, const armarx::aron::Path& p = {});
+        static data::DictPtr ConvertFromNlohmannJSONObject(const nlohmann::json&);
         static void ConvertFromNlohmannJSON(data::VariantPtr&, const nlohmann::json&, const aron::type::VariantPtr& = nullptr);
 
-        static type::ObjectPtr ConvertFromNlohmannJSONTypeObject(const nlohmann::json& j, const armarx::aron::Path& p = {});
+        static type::ObjectPtr ConvertFromNlohmannJSONTypeObject(const nlohmann::json& j);
         static void ConvertFromNlohmannJSON(aron::type::VariantPtr& a, const nlohmann::json& e);
     };
 }
diff --git a/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp b/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp
index d232500c20754beb3d2f212a79b6f16939812ef7..6208bd9b451862e74c1f137d70e61711b49299b2 100644
--- a/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp
+++ b/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp
@@ -45,7 +45,7 @@ namespace armarx::aron::converter
         return ret;
     }
 
-    data::NDArrayPtr AronOpenCVConverter::ConvertFromMat(const cv::Mat& mat, const armarx::aron::Path& p)
+    data::NDArrayPtr AronOpenCVConverter::ConvertFromMat(const cv::Mat& mat)
     {
         std::vector<int> dims;
         for (int i = 0; i < mat.dims; ++i)
@@ -54,7 +54,7 @@ namespace armarx::aron::converter
         }
         dims.push_back(mat.elemSize());
 
-        auto ret = std::make_shared<data::NDArray>(p);
+        auto ret = std::make_shared<data::NDArray>();
         ret->setShape(dims);
         ret->setType(std::to_string(mat.type()));
         ret->setData(std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>()), reinterpret_cast<const unsigned char*>(mat.data));
diff --git a/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.h b/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.h
index fb4f21487b413272fc6b1b4cbb340cf819a8a5a7..5223ce3da2a5ca471ebb1d8dcc54a70a347e02be 100644
--- a/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.h
+++ b/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.h
@@ -41,7 +41,7 @@ namespace armarx::aron::converter
 
     public:
         static cv::Mat ConvertToMat(const data::NDArrayPtr&);
-        static data::NDArrayPtr ConvertFromMat(const cv::Mat&, const armarx::aron::Path& = {});
+        static data::NDArrayPtr ConvertFromMat(const cv::Mat&);
     };
 
 }