Feat: Add implicit complement and default material properties

Author: ahnaf-tahmid-chowdhury

src/pydagmc/dagnav.py

@@ -170,6 +170,83 @@ def groups_by_name(self) -> Dict[str, Group]:
     def group_names(self) -> list[str]:
         return self.groups_by_name.keys()
 
+    @property
+    def implicit_complement(self) -> Optional[Volume]:
+        """
+        Returns the implicit complement volume.
+
+        The implicit complement volume is identified as the volume
+        that has the material 'Graveyard'.
+        """
+        for volume in self.volumes:
+            if volume.material == 'Graveyard':
+                return volume
+        return None
+
+    @property
+    def implicit_complement_material(self) -> Optional[str]:
+        """
+        The material of the implicit complement.
+        """
+        # Find group with name like 'mat:*_comp'
+        for group in self.groups:
+            if group.name and group.name.startswith('mat:') and group.name.endswith('_comp'):
+                return group.name.removeprefix('mat:').removesuffix('_comp')
+        return None
+
+    @implicit_complement_material.setter
+    def implicit_complement_material(self, material_name: Optional[str]):
+        """
+        Set the material of the implicit complement.
+        """
+        # First, find and unset any existing implicit complement material group
+        for group in self.groups:
+            if group.name and group.name.startswith('mat:') and group.name.endswith('_comp'):
+                group.name = group.name.removesuffix('_comp')
+                break
+
+        if material_name is not None:
+            # Find the group for the new material
+            material_group_name = f"mat:{material_name}"
+            if material_group_name in self.groups_by_name:
+                group = self.groups_by_name[material_group_name]
+                group.name = f"{group.name}_comp"
+            else:
+                # If the group does not exist, we need to find the graveyard and assign it.
+                graveyard = self.implicit_complement
+                if graveyard is None:
+                    raise ValueError("Could not identify the implicit complement volume.")
+                graveyard.material = material_name
+                graveyard.material_group.name = f"{graveyard.material_group.name}_comp"
+
+    @property
+    def default_material(self) -> Optional[str]:
+        """
+        The default material for volumes without a material.
+        """
+        for group in self.groups:
+            if group.name and group.name.startswith('pydagmc:default_material:'):
+                return group.name.split(':')[-1]
+        return None
+
+    @default_material.setter
+    def default_material(self, material_name: Optional[str]):
+        """
+        Set the default material for volumes without a material.
+        """
+        # First, remove any existing default material marker
+        for group in self.groups:
+            if group.name and group.name.startswith('pydagmc:default_material:'):
+                group.delete()
+                break
+
+        if material_name is not None:
+            # Assign the material to all volumes without one.
+            for volume in self.volumes_without_material:
+                volume.material = material_name
+            # Create a marker group to store the default material name
+            self.create_group(name=f'pydagmc:default_material:{material_name}')
+
     def __repr__(self):
         return f'{type(self).__name__}: {len(self.volumes)} Volumes, {len(self.surfaces)} Surfaces, {len(self.groups)} Groups'
 
@@ -670,11 +747,17 @@ def material_group(self) -> Optional[Group]:
     @property
     def material(self) -> Optional[str]:
         """Name of the material assigned to this volume."""
-        return self._metadata_group_name(self._material_prefix)
+        name = self._metadata_group_name(self._material_prefix)
+        if name:
+            return name.removesuffix('_comp')
+        return None
 
     @material.setter
     def material(self, name: str):
+        is_comp = self.material_group and self.material_group.name.endswith('_comp')
         self._set_metadata_group(self._material_prefix, name)
+        if is_comp:
+            self.material_group.name += '_comp'
 
     @property
     def surfaces(self) -> list[Surface]:
@@ -732,11 +815,13 @@ def name(self) -> Optional[str]:
 
     @name.setter
     def name(self, val: str):
-        if val.lower() in self.model.group_names:
+        current_name = self.name
+        if val.lower() in self.model.group_names and val.lower() != current_name.lower():
             raise ValueError(f'Group {val} already used in model.')
 
         self.model.mb.tag_set_data(self.model.name_tag, self.handle, val)
 
+
     def _get_geom_ent_by_id(self, entity_type, id):
         category_ents = self.model.mb.get_entities_by_type_and_tag(self.handle, types.MBENTITYSET, [self.model.category_tag], [entity_type])
         ids = self.model.mb.tag_get_data(self.model.id_tag, category_ents, flat=True)

test/test_dagnav.py

@@ -1017,3 +1017,64 @@ def test_geometryset_check_tags_errors(request):
     with pytest.raises(ValueError, match="has no category or geom_dimension"):
         _ = pydagmc.Surface(model, raw_handle_surf_missing_all)
 
+def test_implicit_complement_material(fuel_pin_model):
+    model = fuel_pin_model
+
+    # The graveyard volume is volume 6 in the test model
+    graveyard = model.volumes_by_id[6]
+    assert model.implicit_complement == graveyard
+
+    # Initially, no implicit complement material is set
+    assert model.implicit_complement_material is None
+    assert graveyard.material == 'Graveyard'
+
+    # Set the implicit complement material to the existing material of the graveyard
+    model.implicit_complement_material = 'Graveyard'
+    assert model.implicit_complement_material == 'Graveyard'
+    assert graveyard.material_group.name == 'mat:Graveyard_comp'
+    assert graveyard.material == 'Graveyard' # Should not change
+
+    # Set the implicit complement material to a new material
+    model.implicit_complement_material = 'water'
+    assert model.implicit_complement_material == 'water'
+    assert 'mat:Graveyard' in model.groups_by_name
+    assert len(model.groups_by_name['mat:Graveyard'].volumes) == 0
+    assert 'mat:water_comp' in model.groups_by_name
+    assert graveyard in model.groups_by_name['mat:water_comp'].volumes
+    assert graveyard.material == 'water'
+    assert graveyard.material_group.name == 'mat:water_comp'
+
+    # Set back to None
+    model.implicit_complement_material = None
+    assert model.implicit_complement_material is None
+    assert graveyard.material_group.name == 'mat:water'
+    assert graveyard.material == 'water'
+
+def test_default_material(fuel_pin_model):
+    model = fuel_pin_model
+
+    # Initially, no default material is set
+    assert model.default_material is None
+
+    # Create a new volume, which should not have a material
+    new_volume = model.create_volume()
+    assert new_volume.material is None
+
+    # Check that the new volume is in the list of volumes without material
+    volumes_without_material = model.volumes_without_material
+    assert new_volume in volumes_without_material
+
+    # Set the default material
+    model.default_material = 'steel'
+    assert model.default_material == 'steel'
+
+    # Check that the new volume now has the default material
+    assert new_volume.material == 'steel'
+
+    # Unset the default material
+    model.default_material = None
+    assert model.default_material is None
+
+    # The material should remain assigned to the volume
+    assert new_volume.material == 'steel'
+