IfcOpenShell/src/ifcopenshell-python/ifcopenshell/api/cost/assign_cost_item_quantity.py

# IfcOpenShell - IFC toolkit and geometry engine
# Copyright (C) 2021 Dion Moult <dion@thinkmoult.com>
#
# This file is part of IfcOpenShell.
#
# IfcOpenShell is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# IfcOpenShell is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with IfcOpenShell.  If not, see <http://www.gnu.org/licenses/>.

import ifcopenshell.api.cost
import ifcopenshell.api.control
import ast
from typing import Any

import ifcopenshell.api.control
import ifcopenshell.api.cost


def assign_cost_item_quantity(
    file: ifcopenshell.file,
    cost_item: ifcopenshell.entity_instance,
    products: list[ifcopenshell.entity_instance],
    prop_name: str = "",
    formula: str = "",
    ifc_class: str = "IfcQuantityLength",
) -> None:
    """Adds a cost item quantity that is parametrically connected to a product

    A cost item may have its subtotal calculated by multiplying a unit value
    by a quantity associated with the cost item. That quantity may be either
    manually specified or parametrically connected to a quantity on a
    product. This API function lets you create that parametric connection.

    For example, you may wish to have a cost item linked to the "NetVolume"
    quantity on all IfcSlabs. Each quantity has a name which you can
    specify. If the quantity is updated in-place (which should occur for
    Native IFC applications) then the quantity for the cost item will
    automatically update as well. If the quantity is deleted and then
    re-added, then the parametric relationship is also lost.

    This API also automatically assigns a control relationship between the
    cost item and the product, so it is not necessary to use
    ifcopenshell.api.control.assign_control.

    If cost item has just 1 quantity and it's IfcQuantityCount, API will
    assume that quantity is used for counting controlled objects
    and it will recalculate the quantity value at the end of the API call
    as long as the RelatedObjects are not IfcConstructionResource which do not
    count towards the cost item (they only provide value).

    :param cost_item: The IfcCostItem to assign parametric quantities to
    :param products: The IfcObjects to assign parametric quantities to
    :param prop_name: The name of the quantity. If this is not specified,
        then it is assumed that there is no calculated quantity, and the
        number of objects are counted instead.
    :param formula: The string that contains the formula
    :param ifc_class: The quantity class of the calculated value if the formula is
        specified. Can be ['IfcQuantityCount', 'IfcQuantityNumber',
        'IfcQuantityLength', 'IfcQuantityArea', 'IfcQuantityVolume',
        'IfcQuantityWeight', 'IfcQuantityTime']. Check
        ifcopenshell.util.unit.QUANTITY_CLASS for more info.
    :return: None

    Example:

    .. code:: python

        schedule = ifcopenshell.api.cost.add_cost_schedule(model)
        item = ifcopenshell.api.cost.add_cost_item(model, cost_schedule=schedule)

        # Let's imagine a unit cost of 5.0 per unit volume
        value = ifcopenshell.api.cost.add_cost_value(model, parent=item)
        ifcopenshell.api.cost.edit_cost_value(model, cost_value=value,
            attributes={"AppliedValue": 5.0})

        slab = ifcopenshell.api.root.create_entity(model, ifc_class="IfcSlab")
        # Usually the quantity would be automatically calculated via a
        # graphical authoring application but let's assign a manual quantity
        # for now.
        qto = ifcopenshell.api.pset.add_qto(model, product=slab, name="Qto_SlabBaseQuantities")
        ifcopenshell.api.pset.edit_qto(model, qto=qto, properties={"NetVolume": 42.0})

        # Now let's parametrically link the slab's quantity to the cost
        # item. If the slab is edited in the future and 42.0 changes, then
        # the updated value will also automatically be applied to the cost
        # item.
        ifcopenshell.api.cost.assign_cost_item_quantity(model,
            cost_item=item, products=[slab], prop_name="NetVolume")

        # Now let's use the formula in order to calculate the quantity value.
        # For example, let's say that a IfcWall has the reinfocement volume ratio
        # stored in the Pset_ConcreteElementGeneral.ReinforcementVolumeRatio
        # and of course it has also the gross volume stored in the
        # Qto_WallBaseQuantities.GrossVolume. So we can add an IfcQuantity that stores the
        # reinforcement volume calculated with reinfocement volume ratio * gross volume.
        ifcopenshell.api.cost.assign_cost_item_quantity(model,
            cost_item=item, products=[wall],
            formula="Pset_ConcreteElementGeneral.ReinforcementVolumeRatio * NetVolume"
            ifc_class="IfcQuantityVolume")

    """
    usecase = Usecase()
    usecase.file = file
    usecase.settings = {
        "cost_item": cost_item,
        "products": products or [],
        "prop_name": prop_name,
        "formula": formula,
        "ifc_class" : ifc_class
    }
    return usecase.execute()


class Usecase:
    file: ifcopenshell.file
    settings: dict[str, Any]

    def execute(self):
        if self.settings["prop_name"]:
            self.quantities = set(self.settings["cost_item"].CostQuantities or [])
        for product in self.settings["products"]:
            if product.is_a("IfcSpatialElement"):
                continue
            self.assign_cost_control(related_object=product, cost_item=self.settings["cost_item"])
            if self.settings["formula"]:
                # not so much elegant, but simple and useful because variables can't has the dot in the name
                # and Psets have the dot
                separator = "0"
                variables = self.extract_variables(self.settings["formula"])
                variables_modified = {v.replace(".", separator) : None for v in variables}
                for v in variables_modified:
                    if separator in v:
                        variables_modified[v] = self.get_value_from_pset(product, v, separator)
                    else:
                        variables_modified[v] = self.get_value_from_qset(product, v)

                formula_modified = self.settings["formula"].replace(".", separator)
                if any(v is None for v in variables_modified.values()):
                    for k, v in variables_modified.items():
                        if v == None:
                            print(f"Property {k.replace(separator, '.')} not found")
                    raise ValueError("Formula contains variables that are not found in properties. Please check the output")

                result = eval(formula_modified, {}, variables_modified)

                new_quantity = None
                self.quantities = set(self.settings["cost_item"].CostQuantities or [])
                for quantity in self.quantities:
                    if quantity.Formula == self.settings["formula"]:
                        new_quantity = quantity
                        self.settings["ifc_class"] = quantity.is_a()
                        continue
                if new_quantity is None:
                    new_quantity = self.file.create_entity(self.settings["ifc_class"], Name="Unnamed")
                    new_quantity.Formula = self.settings["formula"]
                    self.quantities.add(new_quantity)

                new_quantity[3] = result
                continue

            if self.settings["prop_name"]:
                if (
                    self.settings["cost_item"].CostQuantities
                    and self.settings["cost_item"].CostQuantities[0].Name.lower() != self.settings["prop_name"].lower()
                ):
                    continue
                self.add_quantity_from_related_object(product)
        if self.settings["prop_name"] or self.settings["formula"]:
            self.settings["cost_item"].CostQuantities = list(self.quantities)
        else:
            self.update_cost_item_count()

    def assign_cost_control(
        self, related_object: ifcopenshell.entity_instance, cost_item: ifcopenshell.entity_instance
    ) -> ifcopenshell.entity_instance:
        return ifcopenshell.api.control.assign_control(
            self.file,
            related_objects=[related_object],
            relating_control=cost_item,
        )

    def add_quantity_from_related_object(self, element: ifcopenshell.entity_instance) -> None:
        for relationship in element.IsDefinedBy:
            if relationship.is_a("IfcRelDefinesByProperties"):
                self.add_quantity_from_qto(relationship.RelatingPropertyDefinition)

    def add_quantity_from_qto(self, qto: ifcopenshell.entity_instance) -> None:
        if not qto.is_a("IfcElementQuantity"):
            return
        for prop in qto.Quantities:
            if prop.is_a("IfcPhysicalSimpleQuantity") and prop.Name.lower() == self.settings["prop_name"].lower():
                self.quantities.add(prop)

    def update_cost_item_count(self):
        # This is a bold assumption
        # https://forums.buildingsmart.org/t/how-does-a-cost-item-know-that-it-is-counting-a-controlled-product/3564
        if not self.settings["cost_item"].CostQuantities:
            ifcopenshell.api.cost.add_cost_item_quantity(
                self.file,
                cost_item=self.settings["cost_item"],
                ifc_class="IfcQuantityCount",
            )
        if len(self.settings["cost_item"].CostQuantities) == 1:
            quantity = self.settings["cost_item"].CostQuantities[0]
            if quantity.is_a("IfcQuantityCount"):
                count = 0
                for rel in self.settings["cost_item"].Controls:
                    for obj in rel.RelatedObjects:
                        # Only increment if not a resource
                        if not obj.is_a("IfcConstructionResource"):
                            count += 1
                quantity[3] = count

    def extract_variables(self, expr: str):
        tree = ast.parse(expr, mode="eval")
        extractor = VariableExtractor()
        extractor.visit(tree)
        return extractor.variables

    def get_value_from_pset(
            self,
            product:ifcopenshell.entity_instance,
            v: str,
            separator: str,
    ) -> float:
        for relationship in product.IsDefinedBy:
            if relationship.is_a("IfcRelDefinesByProperties"):
                pset = relationship.RelatingPropertyDefinition
                if pset.Name == v.split(separator)[0]:
                    for prop in pset.HasProperties:
                        if prop.Name.lower() == v.split(separator)[1].lower():
                            return prop[2].wrappedValue

    def get_value_from_qset(
            self,
            product:ifcopenshell.entity_instance,
            v: str,
    ) -> float:
        for relationship in product.IsDefinedBy:
            if relationship.is_a("IfcRelDefinesByProperties"):
                qto = relationship.RelatingPropertyDefinition
                if qto.is_a("IfcElementQuantity"):
                    for prop in qto.Quantities:
                        if prop.is_a("IfcPhysicalSimpleQuantity") and prop.Name.lower() == v.lower():
                            return prop[3]

class VariableExtractor(ast.NodeVisitor):
    def __init__(self):
        self.variables = set()

    def visit_Name(self, node):
        # simple variables wothout dots
        self.variables.add(node.id)

    def visit_Attribute(self, node):
        # for variables with dots (chains)
        parts = []
        current = node
        while isinstance(current, ast.Attribute):
            parts.append(current.attr)
            current = current.value
        if isinstance(current, ast.Name):
            parts.append(current.id)

        full_name = ".".join(reversed(parts))
        self.variables.add(full_name)