fix: resolve Abaqus set namespaces

src/fesa/io/abaqus/domain_mapper.cpp

@@ -398,20 +398,23 @@ private:
             });
     }
 
-    bool containsSetName(const RawPart& part, const std::string& name) const {
+    bool containsSetName(
+        const std::vector<RawSet>& sets,
+        const std::string& name) const {
         const auto matches = [&name](const RawSet& set) {
             return equalName(set.name, name);
         };
-        return std::any_of(part.nodeSets.begin(), part.nodeSets.end(), matches) ||
-               std::any_of(part.elementSets.begin(), part.elementSets.end(), matches);
+        return std::any_of(sets.begin(), sets.end(), matches);
     }
 
-    bool containsAssemblySetName(const std::string& name) const {
+    bool containsAssemblySetName(
+        bool nodeSet,
+        const std::string& name) const {
         return std::any_of(
             assemblySets_.begin(),
             assemblySets_.end(),
-            [&name](const RawAssemblySet& set) {
-                return equalName(set.name, name);
+            [nodeSet, &name](const RawAssemblySet& set) {
+                return set.isNodeSet == nodeSet && equalName(set.name, name);
             });
     }
 
@@ -1025,10 +1028,12 @@ private:
                 "GENERATE is a valueless flag.");
             return;
         }
-        if (containsSetName(part, *name)) {
+        const auto& sets = nodeSet ? part.nodeSets : part.elementSets;
+        if (containsSetName(sets, *name)) {
             inputFailure(
                 "duplicate-entity", block.location, block.canonicalName,
-                *name, "Set names are unique within a part.");
+                *name,
+                "Set names are unique within their node-set or element-set namespace.");
             return;
         }
         RawSet set{*name, {}, block.location};
@@ -1295,10 +1300,11 @@ private:
                 "GENERATE is a valueless flag.");
             return;
         }
-        if (containsAssemblySetName(*name)) {
+        if (containsAssemblySetName(nodeSet, *name)) {
             inputFailure(
                 "duplicate-entity", block.location, block.canonicalName,
-                *name, "Assembly set names are unique.");
+                *name,
+                "Assembly set names are unique within their node-set or element-set namespace.");
             return;
         }
         RawAssemblySet set{nodeSet, *name, *instance, {}, block.location};
@@ -2275,6 +2281,14 @@ private:
                 return;
             }
             if (rawSet.isNodeSet) {
+                definition_.nodeSets.erase(
+                    std::remove_if(
+                        definition_.nodeSets.begin(),
+                        definition_.nodeSets.end(),
+                        [&rawSet](const NodeSet& set) {
+                            return equalName(set.name, rawSet.name);
+                        }),
+                    definition_.nodeSets.end());
                 NodeSet set{
                     rawSet.name, definitionInstance->name, {}, rawSet.location};
                 for (const auto member : rawSet.members) {
@@ -2295,6 +2309,14 @@ private:
                 }
                 definition_.nodeSets.push_back(std::move(set));
             } else {
+                definition_.elementSets.erase(
+                    std::remove_if(
+                        definition_.elementSets.begin(),
+                        definition_.elementSets.end(),
+                        [&rawSet](const ElementSet& set) {
+                            return equalName(set.name, rawSet.name);
+                        }),
+                    definition_.elementSets.end());
                 ElementSet set{
                     rawSet.name, definitionInstance->name, {}, rawSet.location};
                 for (const auto member : rawSet.members) {