IVS-80/GRD000 - Grid Information

features/GRD000_Grid-information.feature

@@ -0,0 +1,26 @@
+@implementer-agreement
+@GRD
+@POS
+@version1
+@E00020
+
+Feature: GRD000 - Grid Information
+    The rule verifies the presence of IFC entities used to define a design grid to be used as reference for object placement.
+    https://ifc43-docs.standards.buildingsmart.org/IFC/RELEASE/IFC4x3/HTML/concepts/Product_Shape/Product_Placement/Product_Grid_Placement/content.html
+
+
+    Scenario: Check for activation
+
+    Given an IfcGridPlacement
+    Given its attribute PlacesObject
+    Given its entity type is 'IfcProduct' including subtypes
+    Given return to IfcGridPlacement
+    Given its attribute PlacementRelTo
+    Given its attribute PlacesObject
+    Given its entity type is 'IfcGrid' 
+    Given return to IfcGridPlacement
+    Given its attribute PlacementLocation
+    Given IntersectingAxes = not empty
+
+    Then The IFC model contains information on quantities of elements
+

features/steps/givens/attributes.py

@@ -4,6 +4,7 @@
 import ifcopenshell
 from behave import register_type
 from utils import geometry, ifc, misc
+from utils.subtype_handling import SubTypeHandling, check_entity_type
 from parse_type import TypeBuilder
 from validation_handling import gherkin_ifc
 from . import ValidationOutcome, OutcomeSeverity
@@ -17,9 +18,6 @@ class ComparisonOperator (Enum):
     EQUAL = auto()
     NOT_EQUAL = auto()
 
-class SubTypeHandling (Enum):
-    INCLUDE = auto()
-    EXCLUDE = auto()
 
 register_type(include_or_exclude_subtypes=TypeBuilder.make_enum({"including subtypes": SubTypeHandling.INCLUDE, "excluding subtypes": SubTypeHandling.EXCLUDE }))
 register_type(first_or_final=TypeBuilder.make_enum({"first": FirstOrFinal.FIRST, "final": FirstOrFinal.FINAL }))
@@ -30,25 +28,6 @@ class SubTypeHandling (Enum):
     "is": ComparisonOperator.EQUAL,
 }))
 
-def check_entity_type(inst: ifcopenshell.entity_instance, entity_type: str, handling: SubTypeHandling) -> bool:
-    """
-    Check if the instance is of a specific entity type or its subtype.
-    INCLUDE will evaluate to True if inst is a subtype of entity_type while the second function for EXCLUDE will evaluate to True only for an exact type match
-
-    Parameters:
-    inst (ifcopenshell.entity_instance): The instance to check.
-    entity_type (str): The entity type to check against.
-    handling (SubTypeHandling): Determines whether to include subtypes or not.
-
-    Returns:
-    bool: True if the instance matches the entity type criteria, False otherwise.
-    """
-    handling_functions = {
-        SubTypeHandling.INCLUDE: lambda inst, entity_type: inst.is_a(entity_type),
-        SubTypeHandling.EXCLUDE: lambda inst, entity_type: inst.is_a() == entity_type,
-    }
-    return handling_functions[handling](inst, entity_type)
-
 @gherkin_ifc.step("{attribute} {comparison_op:equal_or_not_equal} {value}")
 @gherkin_ifc.step("{attribute} {comparison_op:equal_or_not_equal} {value} {tail:include_or_exclude_subtypes}")
 def step_impl(context, inst, comparison_op, attribute, value, tail=SubTypeHandling.EXCLUDE):

features/steps/steps.py

@@ -1,3 +1,3 @@
 from givens import attributes, entities, relationships, values
 from thens import alignment, attributes, existance, geometry, nesting, reference, relations, values
-from steps import attributes
+from steps import attributes, return_to

features/steps/steps/return_to.py

@@ -0,0 +1,50 @@
+from utils import misc, ifc
+
+import ifcopenshell
+from validation_handling import gherkin_ifc, global_rule
+
+from behave import register_type
+from parse_type import TypeBuilder
+from enum import Enum, auto
+
+from utils.subtype_handling import SubTypeHandling, check_entity_type
+
+register_type(include_or_exclude_subtypes=TypeBuilder.make_enum({"including subtypes": SubTypeHandling.INCLUDE, "excluding subtypes": SubTypeHandling.EXCLUDE }))
+
+@global_rule
+@gherkin_ifc.step("Return to {entity}")
+@gherkin_ifc.step("Return to {entity} {include_or_exclude_subtypes:include_or_exclude_subtypes}")
+def step_impl(context, entity, include_or_exclude_subtypes=SubTypeHandling.EXCLUDE):
+    """
+    Disclaimer: Currently untested for normative rules
+
+        | Feature Step               | Context Stack                       |
+        |----------------------------|-------------------------------------|
+        | Given an IfcEntity         | [entity1, entity2, entity3]         |
+        | Given its attribute X      | [attr, None, attr]                  |
+        | Given Y is attr            | [True, False, True]                 |
+        | Given return to IfcEntity  | [entity1, entity2, entity3]         |
+    For rules used for activation, this is not a problem (one is sufficient to activate the rule). 
+    However, for normative rules, we do not want to consider entity2. 
+    Simply using indexes would not work as the stack is often nested.
+    """
+    context.include_or_exclude_subtypes = include_or_exclude_subtypes
+    def filter_stack_tree(layer):
+        def check_inclusion_criteria(input):
+            """
+            Verifies if layer includes a boolean variable or instance of {entity}
+            """
+            is_bool = isinstance(input, bool)
+            correct_entity = False
+            if isinstance(input, ifcopenshell.entity_instance):
+                correct_entity = check_entity_type(input, entity, context.include_or_exclude_subtypes)
+            context.include_layer = is_bool or correct_entity
+        layer = layer.get('instances')
+        misc.map_state(layer, check_inclusion_criteria)
+        return layer if context.include_layer else None
+
+    #ensure the stack does not get pupulated when nothing was yielded in the last step
+    if (lambda f: f(f))(lambda f: lambda data: bool(data) and (not isinstance(data, (list, tuple)) or any(f(f)(item) for item in data)))(context.instances):
+        stack_tree_filtered = list(
+            filter(None, list(map(filter_stack_tree, context._stack))))
+        context.instances = stack_tree_filtered

features/steps/utils/subtype_handling.py

@@ -0,0 +1,26 @@
+import ifcopenshell
+
+from enum import Enum, auto
+
+class SubTypeHandling (Enum):
+    INCLUDE = auto()
+    EXCLUDE = auto()
+
+def check_entity_type(inst: ifcopenshell.entity_instance, entity_type: str, handling: SubTypeHandling) -> bool:
+    """
+    Check if the instance is of a specific entity type or its subtype.
+    INCLUDE will evaluate to True if inst is a subtype of entity_type while the second function for EXCLUDE will evaluate to True only for an exact type match
+
+    Parameters:
+    inst (ifcopenshell.entity_instance): The instance to check.
+    entity_type (str): The entity type to check against.
+    handling (SubTypeHandling): Determines whether to include subtypes or not.
+
+    Returns:
+    bool: True if the instance matches the entity type criteria, False otherwise.
+    """
+    handling_functions = {
+        SubTypeHandling.INCLUDE: lambda inst, entity_type: inst.is_a(entity_type),
+        SubTypeHandling.EXCLUDE: lambda inst, entity_type: inst.is_a() == entity_type,
+    }
+    return handling_functions[handling](inst, entity_type)

features/steps/validation_handling.py

@@ -95,7 +95,7 @@ def handle_given(context, fn, **kwargs):
             context.instances = list(map(attrgetter('instance_id'), filter(lambda res: res.severity == OutcomeSeverity.PASSED, insts)))
             pass
         else:
-            pass # (1) -> context.applicable is set within the function ; replace this with a simple True/False and set applicability here?
+            pass # (1) -> context.applicable is set within the function, e.g. implementations with the 'global_rule' tag
     else:
         context._push('attribute') # for attribute stacking
         if 'at depth 1' in context.step.name: 
@@ -132,10 +132,7 @@ def apply_then_operation(fn, inst, context, current_path, depth=0, **kwargs):
             if inst is None:
                 return
             top_level_index = current_path[0] if current_path else None
-            activation_inst = inst if not current_path or activation_instances[top_level_index] is None else activation_instances[top_level_index]
-#TODO: refactor into a more general solution that works for all rules
-            if "GEM051" in context.feature.name and context.is_global_rule:
-                activation_inst = activation_instances[0]
+            activation_inst = misc.do_try(lambda: activation_instances[0] if not current_path else misc.do_try(lambda: activation_instances[top_level_index], activation_instances[0]), None)
             if isinstance(activation_inst, ifcopenshell.file):
                 activation_inst = None  # in case of blocking IFC101 check, for safety set explicitly to None
 

test/files/grd000/generate.py

@@ -0,0 +1,92 @@
+import ifcopenshell
+import ifcopenshell.template
+import os
+
+rule_code = "grd000"
+
+abs_path = os.path.join(os.getcwd(), "test", "files", rule_code)
+save_ifc_file = lambda file, filename: file.write(os.path.join(abs_path, filename))
+
+f = ifcopenshell.template.create(schema_identifier="IFC4X3_ADD2")
+
+placement = f.createIfcLocalPlacement()
+O = 0., 0., 0.
+X = 1., 0., 0.
+Y = 0., 1., 0.
+Z = 0., 0., 1.
+grid = f.createIfcGrid(
+    GlobalId = ifcopenshell.guid.new(), 
+    ObjectPlacement = placement,
+    UAxes = [f.createIfcGridAxis(
+        AxisTag = "1",
+        AxisCurve = f.createIfcPolyLine([f.createIfcCartesianPoint(O), f.createIfcCartesianPoint(X)]),
+        SameSense = True
+    )],
+    VAxes = [f.createIfcGridAxis(
+        AxisTag = "2",
+        AxisCurve = f.createIfcPolyLine([f.createIfcCartesianPoint(O), f.createIfcCartesianPoint(Y)]),
+        SameSense = True
+    )], 
+    WAxes = [f.createIfcGridAxis(
+        AxisTag = "3",
+        AxisCurve = f.createIfcPolyLine([f.createIfcCartesianPoint(O), f.createIfcCartesianPoint(Z)]),
+        SameSense = True
+    )]
+    )
+
+save_ifc_file(f, f'pass-{rule_code}-not_activated_no_placement.ifc')
+
+
+grid_axis_1 = f.createIfcGridAxis(
+    AxisTag = "Axis 1",
+    AxisCurve = f.createIfcPolyLine([f.createIfcCartesianPoint(O), f.createIfcCartesianPoint(X)]), 
+    SameSense = True
+    )
+
+grid_axis_2 = f.createIfcGridAxis(
+    AxisTag = "Axis 2",
+    AxisCurve = f.createIfcPolyLine([f.createIfcCartesianPoint(O), f.createIfcCartesianPoint(Y)]),
+    SameSense = True
+    )
+
+grid_placement = f.createIfcGridPlacement(
+    PlacementRelTo = placement,
+    )
+
+column = f.createIfcColumn(
+    GlobalId = ifcopenshell.guid.new(),
+    ObjectPlacement = grid_placement,
+)
+
+grid.ObjectPlacement = placement
+
+grid_placement.PlacementLocation = f.createIfcVirtualGridIntersection(
+    [grid_axis_1, grid_axis_2], 
+    (0.0, 0.0, 0.0)
+    )
+
+save_ifc_file(f, f'pass-{rule_code}-activated_valid_grid_placement.ifc')
+
+f = ifcopenshell.template.create(schema_identifier="IFC4X3_ADD2")
+
+column = f.createIfcColumn(
+    GlobalId = ifcopenshell.guid.new(),
+    ObjectPlacement = f.createIfcGridPlacement(
+        PlacementLocation = f.createIfcVirtualGridIntersection(
+            [
+                f.createIfcGridAxis(
+                    AxisTag = "Axis 1",
+                    AxisCurve = f.createIfcPolyLine([f.createIfcCartesianPoint(O), f.createIfcCartesianPoint(X)]),
+                    SameSense = True
+                ),
+                f.createIfcGridAxis(
+                    AxisTag = "Axis 2",
+                    AxisCurve = f.createIfcPolyLine([f.createIfcCartesianPoint(O), f.createIfcCartesianPoint(Y)]),
+                    SameSense = True
+                )
+            ]
+        ),
+    ),
+)
+
+save_ifc_file(f, f'pass-{rule_code}-not_activated_no_grid.ifc')