diff --git a/src/ifcopenshell-python/ifcopenshell/entity_instance.py b/src/ifcopenshell-python/ifcopenshell/entity_instance.py index 9c56c09b73..de3d932b7d 100644 --- a/src/ifcopenshell-python/ifcopenshell/entity_instance.py +++ b/src/ifcopenshell-python/ifcopenshell/entity_instance.py @@ -22,6 +22,7 @@ from __future__ import division from __future__ import print_function import functools +import importlib import numbers import itertools @@ -33,7 +34,7 @@ except ImportError as e: logging = type("logger", (object,), {"exception": staticmethod(lambda s: print(s))}) -def set_derived_atribute(*args): +def set_derived_attribute(*args): raise TypeError("Unable to set derived attribute") @@ -73,7 +74,7 @@ def register_schema_attributes(schema): # resolve to actual functions in wrapper functions = [ - set_derived_atribute + set_derived_attribute if mname == "setArgumentAsDerived" else getattr(ifcopenshell_wrapper.entity_instance, mname) for mname in fn_names @@ -123,17 +124,30 @@ class entity_instance(object): INVALID, FORWARD, INVERSE = range(3) attr_cat = self.wrapped_data.get_attribute_category(name) if attr_cat == FORWARD: - return entity_instance.wrap_value( - self.wrapped_data.get_argument( - self.wrapped_data.get_argument_index(name) - ), - self.wrapped_data.file, - ) + idx = self.wrapped_data.get_argument_index(name) + if _method_dict[self.is_a(True)][idx] != set_derived_attribute: + # A bit ugly, but we fall through to derived attribute handling below + return entity_instance.wrap_value( + self.wrapped_data.get_argument(idx), self.wrapped_data.file + ) elif attr_cat == INVERSE: - return entity_instance.wrap_value( - self.wrapped_data.get_inverse(name), self.wrapped_data.file - ) - else: + return entity_instance.wrap_value(self.wrapped_data.get_inverse(name), self.wrapped_data.file) + + # derived attribute perhaps? + schema_name = self.wrapped_data.is_a(True).split('.')[0] + rules = importlib.import_module(f"ifcopenshell.express.rules.{schema_name}") + def yield_supertypes(): + decl = ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(self.is_a()) + while decl: + yield decl.name() + decl = decl.supertype() + + for sty in yield_supertypes(): + fn = getattr(rules, f"calc_{sty}_{name}", None) + if fn: + return fn(self) + + if attr_cat != FORWARD: raise AttributeError( "entity instance of type '%s' has no attribute '%s'" % (self.wrapped_data.is_a(True), name) @@ -218,7 +232,7 @@ class entity_instance(object): method = self.method_list[idx] if value is None: - if method is not set_derived_atribute: + if method is not set_derived_attribute: self.wrapped_data.setArgumentAsNull(idx) else: self.method_list[idx]( @@ -275,17 +289,22 @@ class entity_instance(object): def __eq__(self, other): if not isinstance(self, type(other)): return False - # Proper entity instances have a stable identity by means of the numeric - # step id. Selected type instances (such as IfcPropertySingleValue.NominalValue - # always have id=0, so we compare - if self.id(): - return self.wrapped_data == other.wrapped_data + elif None in (self.wrapped_data.file, other.wrapped_data.file): + # when not added to a file, we can only compare attribute values + # and we need this for where rule evaluation + return self.get_info(recursive=True, include_identifier=False) == other.get_info(recursive=True, include_identifier=False) else: - return (self.is_a(), self[0], self.wrapped_data.file_pointer()) == ( - other.is_a(), - other[0], - other.wrapped_data.file_pointer(), - ) + # Proper entity instances have a stable identity by means of the numeric + # step id. Selected type instances (such as IfcPropertySingleValue.NominalValue + # always have id=0, so we compare + if self.id(): + return self.wrapped_data == other.wrapped_data + else: + return (self.is_a(), self[0], self.wrapped_data.file_pointer()) == ( + other.is_a(), + other[0], + other.wrapped_data.file_pointer(), + ) def __hash__(self): # Proper entity instances have a stable identity by means of the numeric diff --git a/src/ifcopenshell-python/ifcopenshell/express/__init__.py b/src/ifcopenshell-python/ifcopenshell/express/__init__.py index d77e76bf96..d7a0ceebc4 100644 --- a/src/ifcopenshell-python/ifcopenshell/express/__init__.py +++ b/src/ifcopenshell-python/ifcopenshell/express/__init__.py @@ -29,11 +29,9 @@ if not os.path.exists(exp_parser_fn): with open(exp_parser_fn, "w") as f: subprocess.call([sys.executable, "bootstrap.py"], cwd=d, stdout=f) -import express_parser -import schema_class -import ifcopenshell.ifcopenshell_wrapper - def parse(fn): + import express_parser + import schema_class mapping = express_parser.parse(fn) return schema_class.SchemaClass(mapping, schema_class.LateBoundSchemaInstantiator).code diff --git a/src/ifcopenshell-python/ifcopenshell/express/bootstrap.py b/src/ifcopenshell-python/ifcopenshell/express/bootstrap.py index 444033fda0..c7e126c8e1 100644 --- a/src/ifcopenshell-python/ifcopenshell/express/bootstrap.py +++ b/src/ifcopenshell-python/ifcopenshell/express/bootstrap.py @@ -151,6 +151,8 @@ actions = { "string_type": "StringType", "named_types": "NamedType", "simple_types": "SimpleType", + "function_decl": "FunctionDeclaration", + "rule_decl": "RuleDeclaration", } to_emit = set(id for id, expr in express) @@ -192,7 +194,9 @@ for id in to_emit: if id in to_combine: stmt = "Suppress%s" % stmt if id not in no_action and not isinstance(expr.contents, Keyword): - node_type = "ListNode" if "ZeroOrMore" in stmt else "Node" + children = list(map(operator.attrgetter('contents'), reduce(lambda x, y: x | y, (find_bytype(e, Keyword) for e in [expr])))) + has_duplicates = len(children) > len(set(children)) + node_type = "ListNode" if ("ZeroOrMore" in stmt or has_duplicates) else "Node" action = ".setParseAction(%s)" % ( actions[id] if id in actions else 'lambda s, loc, t: %s(s, loc, t, rule="%s")' % (node_type, id) ) diff --git a/src/ifcopenshell-python/ifcopenshell/express/codegen.py b/src/ifcopenshell-python/ifcopenshell/express/codegen.py index 0928433500..efdd9c918d 100644 --- a/src/ifcopenshell-python/ifcopenshell/express/codegen.py +++ b/src/ifcopenshell-python/ifcopenshell/express/codegen.py @@ -16,6 +16,18 @@ # You should have received a copy of the GNU Lesser General Public License # along with IfcOpenShell. If not, see . +import itertools +import functools + + +def indent(n, s): + if isinstance(s, str): + strs = [s] + else: + strs = s + splitted = itertools.chain.from_iterable(map(functools.partial(str.split, sep="\n"), map(str, strs))) + return "\n".join(" "*n + l for l in splitted) + class Base(object): """ diff --git a/src/ifcopenshell-python/ifcopenshell/express/express_parser.py b/src/ifcopenshell-python/ifcopenshell/express/express_parser.py index a41bf11c07..61c88ef8ed 100644 --- a/src/ifcopenshell-python/ifcopenshell/express/express_parser.py +++ b/src/ifcopenshell-python/ifcopenshell/express/express_parser.py @@ -152,7 +152,7 @@ def parse(fn): special = ((not_paren_star_quote_special | CaselessLiteral("(") | CaselessLiteral(")") | CaselessLiteral("*") | CaselessLiteral("\"\""))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="special"))("special") binary_literal = ((CaselessLiteral("%") + bit + ZeroOrMore(bit))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="binary_literal"))("binary_literal") integer_literal = (digits)("integer_literal") - simple_id = ~CaselessKeyword("abstract") + ~CaselessKeyword("reference") + ~CaselessKeyword("pi") + ~CaselessKeyword("andor") + ~CaselessKeyword("loindex") + ~CaselessKeyword("aggregate") + ~CaselessKeyword("self") + ~CaselessKeyword("length") + ~CaselessKeyword("optional") + ~CaselessKeyword("for") + ~CaselessKeyword("end") + ~CaselessKeyword("local") + ~CaselessKeyword("true") + ~CaselessKeyword("logical") + ~CaselessKeyword("constant") + ~CaselessKeyword("nvl") + ~CaselessKeyword("bag") + ~CaselessKeyword("repeat") + ~CaselessKeyword("boolean") + ~CaselessKeyword("otherwise") + ~CaselessKeyword("type") + ~CaselessKeyword("typeof") + ~CaselessKeyword("alias") + ~CaselessKeyword("in") + ~CaselessKeyword("mod") + ~CaselessKeyword("escape") + ~CaselessKeyword("or") + ~CaselessKeyword("of") + ~CaselessKeyword("like") + ~CaselessKeyword("value_unique") + ~CaselessKeyword("tan") + ~CaselessKeyword("oneof") + ~CaselessKeyword("log") + ~CaselessKeyword("schema") + ~CaselessKeyword("fixed") + ~CaselessKeyword("by") + ~CaselessKeyword("integer") + ~CaselessKeyword("div") + ~CaselessKeyword("log10") + ~CaselessKeyword("not") + ~CaselessKeyword("skip") + ~CaselessKeyword("odd") + ~CaselessKeyword("return") + ~CaselessKeyword("end_subtype_constraint") + ~CaselessKeyword("end_alias") + ~CaselessKeyword("remove") + ~CaselessKeyword("unknown") + ~CaselessKeyword("end_repeat") + ~CaselessKeyword("enumeration") + ~CaselessKeyword("query") + ~CaselessKeyword("function") + ~CaselessKeyword("list") + ~CaselessKeyword("end_local") + ~CaselessKeyword("cos") + ~CaselessKeyword("atan") + ~CaselessKeyword("hibound") + ~CaselessKeyword("rolesof") + ~CaselessKeyword("end_function") + ~CaselessKeyword("abs") + ~CaselessKeyword("renamed") + ~CaselessKeyword("select") + ~CaselessKeyword("end_if") + ~CaselessKeyword("case") + ~CaselessKeyword("sizeof") + ~CaselessKeyword("var") + ~CaselessKeyword("end_case") + ~CaselessKeyword("acos") + ~CaselessKeyword("supertype") + ~CaselessKeyword("then") + ~CaselessKeyword("inverse") + ~CaselessKeyword("hiindex") + ~CaselessKeyword("false") + ~CaselessKeyword("generic") + ~CaselessKeyword("as") + ~CaselessKeyword("use") + ~CaselessKeyword("end_entity") + ~CaselessKeyword("rule") + ~CaselessKeyword("derive") + ~CaselessKeyword("set") + ~CaselessKeyword("subtype") + ~CaselessKeyword("unique") + ~CaselessKeyword("subtype_constraint") + ~CaselessKeyword("where") + ~CaselessKeyword("until") + ~CaselessKeyword("usedin") + ~CaselessKeyword("value") + ~CaselessKeyword("array") + ~CaselessKeyword("sqrt") + ~CaselessKeyword("value_in") + ~CaselessKeyword("to") + ~CaselessKeyword("xor") + ~CaselessKeyword("sin") + ~CaselessKeyword("while") + ~CaselessKeyword("with") + ~CaselessKeyword("string") + ~CaselessKeyword("total_over") + ~CaselessKeyword("binary") + ~CaselessKeyword("exp") + ~CaselessKeyword("and") + ~CaselessKeyword("number") + ~CaselessKeyword("generic_entity") + ~CaselessKeyword("const_e") + ~CaselessKeyword("end_type") + ~CaselessKeyword("log2") + ~CaselessKeyword("lobound") + ~CaselessKeyword("end_procedure") + ~CaselessKeyword("end_schema") + ~CaselessKeyword("end_constant") + ~CaselessKeyword("procedure") + ~CaselessKeyword("else") + ~CaselessKeyword("end_rule") + ~CaselessKeyword("if") + ~CaselessKeyword("based_on") + ~CaselessKeyword("exists") + ~CaselessKeyword("asin") + ~CaselessKeyword("blength") + ~CaselessKeyword("entity") + ~CaselessKeyword("from") + ~CaselessKeyword("format") + ~CaselessKeyword("insert") + ~CaselessKeyword("begin") + ~CaselessKeyword("extensible") + ~CaselessKeyword("real") + originalTextFor(Combine((letter + ZeroOrMore((letter | digit | CaselessLiteral("_"))))))("simple_id") + simple_id = ~CaselessKeyword("bag") + ~CaselessKeyword("lobound") + ~CaselessKeyword("aggregate") + ~CaselessKeyword("reference") + ~CaselessKeyword("abstract") + ~CaselessKeyword("value_unique") + ~CaselessKeyword("if") + ~CaselessKeyword("loindex") + ~CaselessKeyword("format") + ~CaselessKeyword("true") + ~CaselessKeyword("insert") + ~CaselessKeyword("exp") + ~CaselessKeyword("end_type") + ~CaselessKeyword("end") + ~CaselessKeyword("optional") + ~CaselessKeyword("in") + ~CaselessKeyword("like") + ~CaselessKeyword("type") + ~CaselessKeyword("end_rule") + ~CaselessKeyword("repeat") + ~CaselessKeyword("nvl") + ~CaselessKeyword("otherwise") + ~CaselessKeyword("procedure") + ~CaselessKeyword("number") + ~CaselessKeyword("boolean") + ~CaselessKeyword("exists") + ~CaselessKeyword("andor") + ~CaselessKeyword("alias") + ~CaselessKeyword("entity") + ~CaselessKeyword("constant") + ~CaselessKeyword("tan") + ~CaselessKeyword("or") + ~CaselessKeyword("oneof") + ~CaselessKeyword("from") + ~CaselessKeyword("escape") + ~CaselessKeyword("typeof") + ~CaselessKeyword("extensible") + ~CaselessKeyword("div") + ~CaselessKeyword("then") + ~CaselessKeyword("by") + ~CaselessKeyword("unknown") + ~CaselessKeyword("var") + ~CaselessKeyword("pi") + ~CaselessKeyword("inverse") + ~CaselessKeyword("skip") + ~CaselessKeyword("array") + ~CaselessKeyword("end_subtype_constraint") + ~CaselessKeyword("use") + ~CaselessKeyword("self") + ~CaselessKeyword("end_alias") + ~CaselessKeyword("select") + ~CaselessKeyword("for") + ~CaselessKeyword("sizeof") + ~CaselessKeyword("fixed") + ~CaselessKeyword("local") + ~CaselessKeyword("remove") + ~CaselessKeyword("enumeration") + ~CaselessKeyword("end_local") + ~CaselessKeyword("not") + ~CaselessKeyword("function") + ~CaselessKeyword("cos") + ~CaselessKeyword("logical") + ~CaselessKeyword("query") + ~CaselessKeyword("atan") + ~CaselessKeyword("return") + ~CaselessKeyword("schema") + ~CaselessKeyword("hiindex") + ~CaselessKeyword("rolesof") + ~CaselessKeyword("log10") + ~CaselessKeyword("end_function") + ~CaselessKeyword("abs") + ~CaselessKeyword("length") + ~CaselessKeyword("renamed") + ~CaselessKeyword("acos") + ~CaselessKeyword("end_case") + ~CaselessKeyword("case") + ~CaselessKeyword("mod") + ~CaselessKeyword("end_if") + ~CaselessKeyword("list") + ~CaselessKeyword("end_repeat") + ~CaselessKeyword("generic") + ~CaselessKeyword("of") + ~CaselessKeyword("supertype") + ~CaselessKeyword("false") + ~CaselessKeyword("end_entity") + ~CaselessKeyword("odd") + ~CaselessKeyword("integer") + ~CaselessKeyword("hibound") + ~CaselessKeyword("rule") + ~CaselessKeyword("as") + ~CaselessKeyword("derive") + ~CaselessKeyword("log") + ~CaselessKeyword("set") + ~CaselessKeyword("subtype_constraint") + ~CaselessKeyword("unique") + ~CaselessKeyword("value") + ~CaselessKeyword("subtype") + ~CaselessKeyword("until") + ~CaselessKeyword("with") + ~CaselessKeyword("sqrt") + ~CaselessKeyword("where") + ~CaselessKeyword("value_in") + ~CaselessKeyword("to") + ~CaselessKeyword("xor") + ~CaselessKeyword("sin") + ~CaselessKeyword("while") + ~CaselessKeyword("string") + ~CaselessKeyword("usedin") + ~CaselessKeyword("total_over") + ~CaselessKeyword("binary") + ~CaselessKeyword("and") + ~CaselessKeyword("end_schema") + ~CaselessKeyword("generic_entity") + ~CaselessKeyword("end_constant") + ~CaselessKeyword("const_e") + ~CaselessKeyword("based_on") + ~CaselessKeyword("else") + ~CaselessKeyword("asin") + ~CaselessKeyword("blength") + ~CaselessKeyword("real") + ~CaselessKeyword("end_procedure") + ~CaselessKeyword("log2") + ~CaselessKeyword("begin") + originalTextFor(Combine((letter + ZeroOrMore((letter | digit | CaselessLiteral("_"))))))("simple_id") simple_string_literal = ((CaselessLiteral("'") + ZeroOrMore(((CaselessLiteral("'") + CaselessLiteral("'")) | not_quote)) + CaselessLiteral("'")))("simple_string_literal") abstract_entity_declaration = (ABSTRACT)("abstract_entity_declaration") abstract_supertype = ((ABSTRACT + SUPERTYPE + CaselessLiteral(";"))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="abstract_supertype"))("abstract_supertype") @@ -250,224 +250,224 @@ def parse(fn): constructed_types = ((enumeration_type | select_type)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="constructed_types"))("constructed_types") reference_clause = ((REFERENCE + FROM + schema_ref + Optional((CaselessLiteral("(") + resource_or_rename + ZeroOrMore((CaselessLiteral(",") + resource_or_rename)) + CaselessLiteral(")"))) + CaselessLiteral(";"))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="reference_clause"))("reference_clause") interface_specification = ((reference_clause | use_clause)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="interface_specification"))("interface_specification") - list_type = Forward()("list_type") - parameter_type = Forward()("parameter_type") - qualifiable_factor = Forward()("qualifiable_factor") - supertype_expression = Forward()("supertype_expression") - precision_spec = Forward()("precision_spec") - element = Forward()("element") - subtype_constraint_decl = Forward()("subtype_constraint_decl") - derived_attr = Forward()("derived_attr") - general_bag_type = Forward()("general_bag_type") - aggregation_types = Forward()("aggregation_types") - entity_decl = Forward()("entity_decl") - rule_decl = Forward()("rule_decl") - numeric_expression = Forward()("numeric_expression") - increment = Forward()("increment") - supertype_constraint = Forward()("supertype_constraint") - concrete_types = Forward()("concrete_types") - remark = Forward()("remark") - width = Forward()("width") - index = Forward()("index") - selector = Forward()("selector") - simple_factor = Forward()("simple_factor") - actual_parameter_list = Forward()("actual_parameter_list") - general_set_type = Forward()("general_set_type") - declaration = Forward()("declaration") - repeat_stmt = Forward()("repeat_stmt") - until_control = Forward()("until_control") - supertype_factor = Forward()("supertype_factor") - one_of = Forward()("one_of") + stmt = Forward()("stmt") + general_aggregation_types = Forward()("general_aggregation_types") procedure_call_stmt = Forward()("procedure_call_stmt") - repetition = Forward()("repetition") - case_action = Forward()("case_action") inverse_attr = Forward()("inverse_attr") - aggregate_initializer = Forward()("aggregate_initializer") - bound_spec = Forward()("bound_spec") - interval_high = Forward()("interval_high") - algorithm_head = Forward()("algorithm_head") - real_type = Forward()("real_type") - case_stmt = Forward()("case_stmt") - constant_decl = Forward()("constant_decl") - alias_stmt = Forward()("alias_stmt") - function_head = Forward()("function_head") - interval_low = Forward()("interval_low") - aggregate_source = Forward()("aggregate_source") - query_expression = Forward()("query_expression") + derived_attr = Forward()("derived_attr") width_spec = Forward()("width_spec") - interval_item = Forward()("interval_item") - subsuper = Forward()("subsuper") - array_type = Forward()("array_type") - primary = Forward()("primary") - case_label = Forward()("case_label") - index_1 = Forward()("index_1") - entity_constructor = Forward()("entity_constructor") - subtype_constraint_body = Forward()("subtype_constraint_body") - constant_body = Forward()("constant_body") + actual_parameter_list = Forward()("actual_parameter_list") + type_decl = Forward()("type_decl") + selector = Forward()("selector") + abstract_supertype_declaration = Forward()("abstract_supertype_declaration") explicit_attr = Forward()("explicit_attr") - entity_body = Forward()("entity_body") - repeat_control = Forward()("repeat_control") - expression = Forward()("expression") - if_stmt = Forward()("if_stmt") - subtype_constraint = Forward()("subtype_constraint") - while_control = Forward()("while_control") - logical_expression = Forward()("logical_expression") - aggregate_type = Forward()("aggregate_type") - interval = Forward()("interval") - general_array_type = Forward()("general_array_type") + aggregation_types = Forward()("aggregation_types") + domain_rule = Forward()("domain_rule") + entity_constructor = Forward()("entity_constructor") + function_call = Forward()("function_call") + numeric_expression = Forward()("numeric_expression") + general_set_type = Forward()("general_set_type") + qualifier = Forward()("qualifier") + formal_parameter = Forward()("formal_parameter") + index_1 = Forward()("index_1") underlying_type = Forward()("underlying_type") - instantiable_type = Forward()("instantiable_type") - supertype_rule = Forward()("supertype_rule") - generalized_types = Forward()("generalized_types") local_variable = Forward()("local_variable") - schema_body = Forward()("schema_body") - general_list_type = Forward()("general_list_type") - assignment_stmt = Forward()("assignment_stmt") - bound_2 = Forward()("bound_2") - binary_type = Forward()("binary_type") - syntax = Forward()("syntax") + aggregate_source = Forward()("aggregate_source") + while_control = Forward()("while_control") + interval_low = Forward()("interval_low") parameter = Forward()("parameter") - string_type = Forward()("string_type") - supertype_term = Forward()("supertype_term") - embedded_remark = Forward()("embedded_remark") - increment_control = Forward()("increment_control") - local_decl = Forward()("local_decl") + precision_spec = Forward()("precision_spec") + one_of = Forward()("one_of") + subtype_constraint_body = Forward()("subtype_constraint_body") + general_array_type = Forward()("general_array_type") + list_type = Forward()("list_type") + subtype_constraint_decl = Forward()("subtype_constraint_decl") + schema_decl = Forward()("schema_decl") + algorithm_head = Forward()("algorithm_head") + query_expression = Forward()("query_expression") + primary = Forward()("primary") + repeat_control = Forward()("repeat_control") factor = Forward()("factor") procedure_head = Forward()("procedure_head") - function_decl = Forward()("function_decl") - type_decl = Forward()("type_decl") - general_aggregation_types = Forward()("general_aggregation_types") - domain_rule = Forward()("domain_rule") - schema_decl = Forward()("schema_decl") - derive_clause = Forward()("derive_clause") - return_stmt = Forward()("return_stmt") - bag_type = Forward()("bag_type") - procedure_decl = Forward()("procedure_decl") - abstract_supertype_declaration = Forward()("abstract_supertype_declaration") - inverse_clause = Forward()("inverse_clause") - index_qualifier = Forward()("index_qualifier") - bound_1 = Forward()("bound_1") - compound_stmt = Forward()("compound_stmt") - set_type = Forward()("set_type") - where_clause = Forward()("where_clause") - qualifier = Forward()("qualifier") - entity_head = Forward()("entity_head") - stmt = Forward()("stmt") - index_2 = Forward()("index_2") - term = Forward()("term") - function_call = Forward()("function_call") - formal_parameter = Forward()("formal_parameter") + aggregate_type = Forward()("aggregate_type") + repeat_stmt = Forward()("repeat_stmt") + entity_body = Forward()("entity_body") + interval_high = Forward()("interval_high") + logical_expression = Forward()("logical_expression") simple_expression = Forward()("simple_expression") + remark = Forward()("remark") + simple_factor = Forward()("simple_factor") + case_stmt = Forward()("case_stmt") + derive_clause = Forward()("derive_clause") + supertype_constraint = Forward()("supertype_constraint") + assignment_stmt = Forward()("assignment_stmt") + entity_head = Forward()("entity_head") + set_type = Forward()("set_type") + instantiable_type = Forward()("instantiable_type") + declaration = Forward()("declaration") + binary_type = Forward()("binary_type") + interval = Forward()("interval") + parameter_type = Forward()("parameter_type") + term = Forward()("term") + index = Forward()("index") + expression = Forward()("expression") + bag_type = Forward()("bag_type") + schema_body = Forward()("schema_body") + until_control = Forward()("until_control") simple_types = Forward()("simple_types") - list_type << (((LIST + Optional(bound_spec) + OF + Optional(UNIQUE) + instantiable_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="list_type")) - parameter_type << (((generalized_types | simple_types | named_types))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="parameter_type")) - qualifiable_factor << (((function_call | attribute_ref | constant_factor | general_ref | population))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="qualifiable_factor")) - supertype_expression << (((supertype_factor + ZeroOrMore((ANDOR + supertype_factor))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="supertype_expression")) - precision_spec << (numeric_expression) - element << (((expression + Optional((CaselessLiteral(":") + repetition))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="element")) - subtype_constraint_decl << (((subtype_constraint_head + subtype_constraint_body + END_SUBTYPE_CONSTRAINT + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subtype_constraint_decl")) - derived_attr << (((attribute_decl + CaselessLiteral(":") + parameter_type + CaselessLiteral(":=") + expression + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="derived_attr")) - general_bag_type << (((BAG + Optional(bound_spec) + OF + parameter_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="general_bag_type")) - aggregation_types << (((array_type | bag_type | list_type | set_type))).setParseAction(AggregationType) - entity_decl << (((entity_head + entity_body + END_ENTITY + CaselessLiteral(";")))).setParseAction(EntityDeclaration) - rule_decl << (((rule_head + algorithm_head + ZeroOrMore(stmt) + where_clause + END_RULE + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="rule_decl")) - numeric_expression << (simple_expression) - increment << (numeric_expression) - supertype_constraint << (((abstract_supertype_declaration | abstract_entity_declaration | supertype_rule))).setParseAction(SuperTypeExpression) - concrete_types << (((aggregation_types | simple_types | type_ref))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="concrete_types")) - remark << (((embedded_remark | tail_remark))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="remark")) - width << (numeric_expression) - index << (numeric_expression) - selector << (expression) - simple_factor << (((aggregate_initializer | interval | query_expression | (Optional(unary_op) + ((CaselessLiteral("(") + expression + CaselessLiteral(")")) | primary)) | entity_constructor | enumeration_reference))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="simple_factor")) - actual_parameter_list << (((CaselessLiteral("(") + Optional(parameter) + ZeroOrMore((CaselessLiteral(",") + parameter)) + CaselessLiteral(")")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="actual_parameter_list")) - general_set_type << (((SET + Optional(bound_spec) + OF + parameter_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="general_set_type")) - declaration << (((entity_decl | function_decl | procedure_decl | subtype_constraint_decl | type_decl))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="declaration")) - repeat_stmt << (((REPEAT + repeat_control + CaselessLiteral(";") + stmt + ZeroOrMore(stmt) + END_REPEAT + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="repeat_stmt")) - until_control << (((UNTIL + logical_expression))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="until_control")) - supertype_factor << (((supertype_term + ZeroOrMore((AND + supertype_term))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="supertype_factor")) - one_of << (((ONEOF + CaselessLiteral("(") + supertype_expression + ZeroOrMore((CaselessLiteral(",") + supertype_expression)) + CaselessLiteral(")")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="one_of")) - procedure_call_stmt << ((((built_in_procedure | procedure_ref) + actual_parameter_list + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="procedure_call_stmt")) - repetition << (numeric_expression) - case_action << (((case_label + ZeroOrMore((CaselessLiteral(",") + case_label)) + CaselessLiteral(":") + stmt))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="case_action")) - inverse_attr << (((attribute_decl + CaselessLiteral(":") + Optional(((SET | BAG) + Optional(bound_spec) + OF)) + entity_ref + FOR + Optional((entity_ref + CaselessLiteral("."))) + attribute_ref + CaselessLiteral(";")))).setParseAction(InverseAttribute) - aggregate_initializer << (((CaselessLiteral("[") + Optional((element + ZeroOrMore((CaselessLiteral(",") + element)))) + CaselessLiteral("]")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="aggregate_initializer")) - bound_spec << (((CaselessLiteral("[") + bound_1 + CaselessLiteral(":") + bound_2 + CaselessLiteral("]")))).setParseAction(BoundSpecification) - interval_high << (simple_expression) - algorithm_head << (((ZeroOrMore(declaration) + Optional(constant_decl) + Optional(local_decl)))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="algorithm_head")) - real_type << (((REAL + Optional((CaselessLiteral("(") + precision_spec + CaselessLiteral(")")))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="real_type")) - case_stmt << (((CASE + selector + OF + ZeroOrMore(case_action) + Optional((OTHERWISE + CaselessLiteral(":") + stmt)) + END_CASE + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="case_stmt")) - constant_decl << (((CONSTANT + constant_body + ZeroOrMore(constant_body) + END_CONSTANT + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="constant_decl")) - alias_stmt << (((ALIAS + variable_id + FOR + general_ref + ZeroOrMore(qualifier) + CaselessLiteral(";") + stmt + ZeroOrMore(stmt) + END_ALIAS + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="alias_stmt")) - function_head << (((FUNCTION + function_id + Optional((CaselessLiteral("(") + formal_parameter + ZeroOrMore((CaselessLiteral(";") + formal_parameter)) + CaselessLiteral(")"))) + CaselessLiteral(":") + parameter_type + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="function_head")) - interval_low << (simple_expression) - aggregate_source << (simple_expression) - query_expression << (((QUERY + CaselessLiteral("(") + variable_id + CaselessLiteral("<*") + aggregate_source + CaselessLiteral("|") + logical_expression + CaselessLiteral(")")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="query_expression")) - width_spec << (((CaselessLiteral("(") + width + CaselessLiteral(")") + Optional(FIXED)))).setParseAction(WidthSpec) - interval_item << (simple_expression) - subsuper << (((Optional(supertype_constraint) + Optional(subtype_declaration)))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subsuper")) - array_type << (((ARRAY + bound_spec + OF + Optional(OPTIONAL) + Optional(UNIQUE) + instantiable_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="array_type")) - primary << (((literal | (qualifiable_factor + ZeroOrMore(qualifier))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="primary")) - case_label << (expression) - index_1 << (index) - entity_constructor << (((entity_ref + CaselessLiteral("(") + Optional((expression + ZeroOrMore((CaselessLiteral(",") + expression)))) + CaselessLiteral(")")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="entity_constructor")) - subtype_constraint_body << (((Optional(abstract_supertype) + Optional(total_over) + Optional((supertype_expression + CaselessLiteral(";")))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subtype_constraint_body")) - constant_body << (((constant_id + CaselessLiteral(":") + instantiable_type + CaselessLiteral(":=") + expression + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="constant_body")) - explicit_attr << (((attribute_decl + ZeroOrMore((CaselessLiteral(",") + attribute_decl)) + CaselessLiteral(":") + Optional(OPTIONAL) + parameter_type + CaselessLiteral(";")))).setParseAction(ExplicitAttribute) - entity_body << (((ZeroOrMore(explicit_attr) + Optional(derive_clause) + Optional(inverse_clause) + Optional(unique_clause) + Optional(where_clause)))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="entity_body")) - repeat_control << (((Optional(increment_control) + Optional(while_control) + Optional(until_control)))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="repeat_control")) - expression << (((simple_expression + Optional((rel_op_extended + simple_expression))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="expression")) - if_stmt << (((IF + logical_expression + THEN + stmt + ZeroOrMore(stmt) + Optional((ELSE + stmt + ZeroOrMore(stmt))) + END_IF + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="if_stmt")) - subtype_constraint << (((OF + CaselessLiteral("(") + supertype_expression + CaselessLiteral(")")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subtype_constraint")) - while_control << (((WHILE + logical_expression))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="while_control")) - logical_expression << (expression) - aggregate_type << (((AGGREGATE + Optional((CaselessLiteral(":") + type_label)) + OF + parameter_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="aggregate_type")) - interval << (((CaselessLiteral("{") + interval_low + interval_op + interval_item + interval_op + interval_high + CaselessLiteral("}")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="interval")) - general_array_type << (((ARRAY + Optional(bound_spec) + OF + Optional(OPTIONAL) + Optional(UNIQUE) + parameter_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="general_array_type")) - underlying_type << (((constructed_types | concrete_types))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="underlying_type")) - instantiable_type << (((concrete_types | entity_ref))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="instantiable_type")) - supertype_rule << (((SUPERTYPE + subtype_constraint))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="supertype_rule")) - generalized_types << (((aggregate_type | general_aggregation_types | generic_entity_type | generic_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="generalized_types")) - local_variable << (((variable_id + ZeroOrMore((CaselessLiteral(",") + variable_id)) + CaselessLiteral(":") + parameter_type + Optional((CaselessLiteral(":=") + expression)) + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="local_variable")) - schema_body << (((ZeroOrMore(interface_specification) + Optional(constant_decl) + ZeroOrMore((declaration | rule_decl))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="schema_body")) - general_list_type << (((LIST + Optional(bound_spec) + OF + Optional(UNIQUE) + parameter_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="general_list_type")) - assignment_stmt << (((general_ref + ZeroOrMore(qualifier) + CaselessLiteral(":=") + expression + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="assignment_stmt")) - bound_2 << (numeric_expression) - binary_type << (((BINARY + Optional(width_spec)))).setParseAction(BinaryType) - syntax << (((schema_decl + ZeroOrMore(schema_decl)))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="syntax")) - parameter << (expression) - string_type << (((STRING + Optional(width_spec)))).setParseAction(StringType) - supertype_term << (((one_of | (CaselessLiteral("(") + supertype_expression + CaselessLiteral(")")) | entity_ref))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="supertype_term")) - embedded_remark << (((CaselessLiteral("(*") + Optional(remark_tag) + ZeroOrMore(((not_paren_star + ZeroOrMore(not_paren_star)) | lparen_then_not_lparen_star | (CaselessLiteral("*") + ZeroOrMore(CaselessLiteral("*"))) | not_rparen_star_then_rparen | embedded_remark)) + CaselessLiteral("*)")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="embedded_remark")) - increment_control << (((variable_id + CaselessLiteral(":=") + bound_1 + TO + bound_2 + Optional((BY + increment))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="increment_control")) - local_decl << (((LOCAL + local_variable + ZeroOrMore(local_variable) + END_LOCAL + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="local_decl")) - factor << (((simple_factor + Optional((CaselessLiteral("**") + simple_factor))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="factor")) - procedure_head << (((PROCEDURE + procedure_id + Optional((CaselessLiteral("(") + Optional(VAR) + formal_parameter + ZeroOrMore((CaselessLiteral(";") + Optional(VAR) + formal_parameter)) + CaselessLiteral(")"))) + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="procedure_head")) - function_decl << (((function_head + algorithm_head + stmt + ZeroOrMore(stmt) + END_FUNCTION + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="function_decl")) - type_decl << (((TYPE + type_id + CaselessLiteral("=") + underlying_type + CaselessLiteral(";") + Optional(where_clause) + END_TYPE + CaselessLiteral(";")))).setParseAction(TypeDeclaration) - general_aggregation_types << (((general_array_type | general_bag_type | general_list_type | general_set_type))).setParseAction(AggregationType) - domain_rule << (((Optional((rule_label_id + CaselessLiteral(":"))) + expression))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="domain_rule")) - schema_decl << (((SCHEMA + schema_id + Optional(schema_version_id) + CaselessLiteral(";") + schema_body + END_SCHEMA + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="schema_decl")) - derive_clause << (((DERIVE + derived_attr + ZeroOrMore(derived_attr)))).setParseAction(AttributeList) - return_stmt << (((RETURN + Optional((CaselessLiteral("(") + expression + CaselessLiteral(")"))) + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="return_stmt")) - bag_type << (((BAG + Optional(bound_spec) + OF + instantiable_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="bag_type")) - procedure_decl << (((procedure_head + algorithm_head + ZeroOrMore(stmt) + END_PROCEDURE + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="procedure_decl")) - abstract_supertype_declaration << (((ABSTRACT + SUPERTYPE + Optional(subtype_constraint)))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="abstract_supertype_declaration")) - inverse_clause << (((INVERSE + inverse_attr + ZeroOrMore(inverse_attr)))).setParseAction(AttributeList) - index_qualifier << (((CaselessLiteral("[") + index_1 + Optional((CaselessLiteral(":") + index_2)) + CaselessLiteral("]")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="index_qualifier")) - bound_1 << (numeric_expression) - compound_stmt << (((BEGIN + stmt + ZeroOrMore(stmt) + END + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="compound_stmt")) - set_type << (((SET + Optional(bound_spec) + OF + instantiable_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="set_type")) - where_clause << (((WHERE + domain_rule + CaselessLiteral(";") + ZeroOrMore((domain_rule + CaselessLiteral(";")))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="where_clause")) - qualifier << (((attribute_qualifier | group_qualifier | index_qualifier))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="qualifier")) - entity_head << (((ENTITY + entity_id + subsuper + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="entity_head")) + subsuper = Forward()("subsuper") + entity_decl = Forward()("entity_decl") + concrete_types = Forward()("concrete_types") + element = Forward()("element") + general_bag_type = Forward()("general_bag_type") + interval_item = Forward()("interval_item") + constant_body = Forward()("constant_body") + increment = Forward()("increment") + case_label = Forward()("case_label") + case_action = Forward()("case_action") + width = Forward()("width") + procedure_decl = Forward()("procedure_decl") + increment_control = Forward()("increment_control") + index_qualifier = Forward()("index_qualifier") + constant_decl = Forward()("constant_decl") + supertype_rule = Forward()("supertype_rule") + syntax = Forward()("syntax") + function_head = Forward()("function_head") + repetition = Forward()("repetition") + if_stmt = Forward()("if_stmt") + supertype_expression = Forward()("supertype_expression") + inverse_clause = Forward()("inverse_clause") + aggregate_initializer = Forward()("aggregate_initializer") + return_stmt = Forward()("return_stmt") + generalized_types = Forward()("generalized_types") + bound_2 = Forward()("bound_2") + real_type = Forward()("real_type") + index_2 = Forward()("index_2") + array_type = Forward()("array_type") + local_decl = Forward()("local_decl") + supertype_term = Forward()("supertype_term") + where_clause = Forward()("where_clause") + embedded_remark = Forward()("embedded_remark") + compound_stmt = Forward()("compound_stmt") + bound_1 = Forward()("bound_1") + alias_stmt = Forward()("alias_stmt") + subtype_constraint = Forward()("subtype_constraint") + string_type = Forward()("string_type") + function_decl = Forward()("function_decl") + general_list_type = Forward()("general_list_type") + supertype_factor = Forward()("supertype_factor") + rule_decl = Forward()("rule_decl") + qualifiable_factor = Forward()("qualifiable_factor") + bound_spec = Forward()("bound_spec") stmt << (((alias_stmt | assignment_stmt | case_stmt | compound_stmt | escape_stmt | if_stmt | null_stmt | procedure_call_stmt | repeat_stmt | return_stmt | skip_stmt))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="stmt")) - index_2 << (index) - term << (((factor + ZeroOrMore((multiplication_like_op + factor))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="term")) + general_aggregation_types << (((general_array_type | general_bag_type | general_list_type | general_set_type))).setParseAction(AggregationType) + procedure_call_stmt << ((((built_in_procedure | procedure_ref) + actual_parameter_list + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="procedure_call_stmt")) + inverse_attr << (((attribute_decl + CaselessLiteral(":") + Optional(((SET | BAG) + Optional(bound_spec) + OF)) + entity_ref + FOR + Optional((entity_ref + CaselessLiteral("."))) + attribute_ref + CaselessLiteral(";")))).setParseAction(InverseAttribute) + derived_attr << (((attribute_decl + CaselessLiteral(":") + parameter_type + CaselessLiteral(":=") + expression + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="derived_attr")) + width_spec << (((CaselessLiteral("(") + width + CaselessLiteral(")") + Optional(FIXED)))).setParseAction(WidthSpec) + actual_parameter_list << (((CaselessLiteral("(") + Optional(parameter) + ZeroOrMore((CaselessLiteral(",") + parameter)) + CaselessLiteral(")")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="actual_parameter_list")) + type_decl << (((TYPE + type_id + CaselessLiteral("=") + underlying_type + CaselessLiteral(";") + Optional(where_clause) + END_TYPE + CaselessLiteral(";")))).setParseAction(TypeDeclaration) + selector << (expression) + abstract_supertype_declaration << (((ABSTRACT + SUPERTYPE + Optional(subtype_constraint)))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="abstract_supertype_declaration")) + explicit_attr << (((attribute_decl + ZeroOrMore((CaselessLiteral(",") + attribute_decl)) + CaselessLiteral(":") + Optional(OPTIONAL) + parameter_type + CaselessLiteral(";")))).setParseAction(ExplicitAttribute) + aggregation_types << (((array_type | bag_type | list_type | set_type))).setParseAction(AggregationType) + domain_rule << (((Optional((rule_label_id + CaselessLiteral(":"))) + expression))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="domain_rule")) + entity_constructor << (((entity_ref + CaselessLiteral("(") + Optional((expression + ZeroOrMore((CaselessLiteral(",") + expression)))) + CaselessLiteral(")")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="entity_constructor")) function_call << ((((built_in_function | function_ref) + actual_parameter_list))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="function_call")) + numeric_expression << (simple_expression) + general_set_type << (((SET + Optional(bound_spec) + OF + parameter_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="general_set_type")) + qualifier << (((attribute_qualifier | group_qualifier | index_qualifier))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="qualifier")) formal_parameter << (((parameter_id + ZeroOrMore((CaselessLiteral(",") + parameter_id)) + CaselessLiteral(":") + parameter_type))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="formal_parameter")) + index_1 << (index) + underlying_type << (((constructed_types | concrete_types))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="underlying_type")) + local_variable << (((variable_id + ZeroOrMore((CaselessLiteral(",") + variable_id)) + CaselessLiteral(":") + parameter_type + Optional((CaselessLiteral(":=") + expression)) + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="local_variable")) + aggregate_source << (simple_expression) + while_control << (((WHILE + logical_expression))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="while_control")) + interval_low << (simple_expression) + parameter << (expression) + precision_spec << (numeric_expression) + one_of << (((ONEOF + CaselessLiteral("(") + supertype_expression + ZeroOrMore((CaselessLiteral(",") + supertype_expression)) + CaselessLiteral(")")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="one_of")) + subtype_constraint_body << (((Optional(abstract_supertype) + Optional(total_over) + Optional((supertype_expression + CaselessLiteral(";")))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subtype_constraint_body")) + general_array_type << (((ARRAY + Optional(bound_spec) + OF + Optional(OPTIONAL) + Optional(UNIQUE) + parameter_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="general_array_type")) + list_type << (((LIST + Optional(bound_spec) + OF + Optional(UNIQUE) + instantiable_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="list_type")) + subtype_constraint_decl << (((subtype_constraint_head + subtype_constraint_body + END_SUBTYPE_CONSTRAINT + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subtype_constraint_decl")) + schema_decl << (((SCHEMA + schema_id + Optional(schema_version_id) + CaselessLiteral(";") + schema_body + END_SCHEMA + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="schema_decl")) + algorithm_head << (((ZeroOrMore(declaration) + Optional(constant_decl) + Optional(local_decl)))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="algorithm_head")) + query_expression << (((QUERY + CaselessLiteral("(") + variable_id + CaselessLiteral("<*") + aggregate_source + CaselessLiteral("|") + logical_expression + CaselessLiteral(")")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="query_expression")) + primary << (((literal | (qualifiable_factor + ZeroOrMore(qualifier))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="primary")) + repeat_control << (((Optional(increment_control) + Optional(while_control) + Optional(until_control)))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="repeat_control")) + factor << (((simple_factor + Optional((CaselessLiteral("**") + simple_factor))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="factor")) + procedure_head << (((PROCEDURE + procedure_id + Optional((CaselessLiteral("(") + Optional(VAR) + formal_parameter + ZeroOrMore((CaselessLiteral(";") + Optional(VAR) + formal_parameter)) + CaselessLiteral(")"))) + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="procedure_head")) + aggregate_type << (((AGGREGATE + Optional((CaselessLiteral(":") + type_label)) + OF + parameter_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="aggregate_type")) + repeat_stmt << (((REPEAT + repeat_control + CaselessLiteral(";") + stmt + ZeroOrMore(stmt) + END_REPEAT + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="repeat_stmt")) + entity_body << (((ZeroOrMore(explicit_attr) + Optional(derive_clause) + Optional(inverse_clause) + Optional(unique_clause) + Optional(where_clause)))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="entity_body")) + interval_high << (simple_expression) + logical_expression << (expression) simple_expression << (((term + ZeroOrMore((add_like_op + term))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="simple_expression")) + remark << (((embedded_remark | tail_remark))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="remark")) + simple_factor << (((aggregate_initializer | interval | query_expression | (Optional(unary_op) + ((CaselessLiteral("(") + expression + CaselessLiteral(")")) | primary)) | entity_constructor | enumeration_reference))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="simple_factor")) + case_stmt << (((CASE + selector + OF + ZeroOrMore(case_action) + Optional((OTHERWISE + CaselessLiteral(":") + stmt)) + END_CASE + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="case_stmt")) + derive_clause << (((DERIVE + derived_attr + ZeroOrMore(derived_attr)))).setParseAction(AttributeList) + supertype_constraint << (((abstract_supertype_declaration | abstract_entity_declaration | supertype_rule))).setParseAction(SuperTypeExpression) + assignment_stmt << (((general_ref + ZeroOrMore(qualifier) + CaselessLiteral(":=") + expression + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="assignment_stmt")) + entity_head << (((ENTITY + entity_id + subsuper + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="entity_head")) + set_type << (((SET + Optional(bound_spec) + OF + instantiable_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="set_type")) + instantiable_type << (((concrete_types | entity_ref))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="instantiable_type")) + declaration << (((entity_decl | function_decl | procedure_decl | subtype_constraint_decl | type_decl))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="declaration")) + binary_type << (((BINARY + Optional(width_spec)))).setParseAction(BinaryType) + interval << (((CaselessLiteral("{") + interval_low + interval_op + interval_item + interval_op + interval_high + CaselessLiteral("}")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="interval")) + parameter_type << (((generalized_types | simple_types | named_types))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="parameter_type")) + term << (((factor + ZeroOrMore((multiplication_like_op + factor))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="term")) + index << (numeric_expression) + expression << (((simple_expression + Optional((rel_op_extended + simple_expression))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="expression")) + bag_type << (((BAG + Optional(bound_spec) + OF + instantiable_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="bag_type")) + schema_body << (((ZeroOrMore(interface_specification) + Optional(constant_decl) + ZeroOrMore((declaration | rule_decl))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="schema_body")) + until_control << (((UNTIL + logical_expression))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="until_control")) simple_types << (((binary_type | boolean_type | integer_type | logical_type | number_type | real_type | string_type))).setParseAction(SimpleType) + subsuper << (((Optional(supertype_constraint) + Optional(subtype_declaration)))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subsuper")) + entity_decl << (((entity_head + entity_body + END_ENTITY + CaselessLiteral(";")))).setParseAction(EntityDeclaration) + concrete_types << (((aggregation_types | simple_types | type_ref))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="concrete_types")) + element << (((expression + Optional((CaselessLiteral(":") + repetition))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="element")) + general_bag_type << (((BAG + Optional(bound_spec) + OF + parameter_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="general_bag_type")) + interval_item << (simple_expression) + constant_body << (((constant_id + CaselessLiteral(":") + instantiable_type + CaselessLiteral(":=") + expression + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="constant_body")) + increment << (numeric_expression) + case_label << (expression) + case_action << (((case_label + ZeroOrMore((CaselessLiteral(",") + case_label)) + CaselessLiteral(":") + stmt))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="case_action")) + width << (numeric_expression) + procedure_decl << (((procedure_head + algorithm_head + ZeroOrMore(stmt) + END_PROCEDURE + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="procedure_decl")) + increment_control << (((variable_id + CaselessLiteral(":=") + bound_1 + TO + bound_2 + Optional((BY + increment))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="increment_control")) + index_qualifier << (((CaselessLiteral("[") + index_1 + Optional((CaselessLiteral(":") + index_2)) + CaselessLiteral("]")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="index_qualifier")) + constant_decl << (((CONSTANT + constant_body + ZeroOrMore(constant_body) + END_CONSTANT + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="constant_decl")) + supertype_rule << (((SUPERTYPE + subtype_constraint))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="supertype_rule")) + syntax << (((schema_decl + ZeroOrMore(schema_decl)))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="syntax")) + function_head << (((FUNCTION + function_id + Optional((CaselessLiteral("(") + formal_parameter + ZeroOrMore((CaselessLiteral(";") + formal_parameter)) + CaselessLiteral(")"))) + CaselessLiteral(":") + parameter_type + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="function_head")) + repetition << (numeric_expression) + if_stmt << (((IF + logical_expression + THEN + stmt + ZeroOrMore(stmt) + Optional((ELSE + stmt + ZeroOrMore(stmt))) + END_IF + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="if_stmt")) + supertype_expression << (((supertype_factor + ZeroOrMore((ANDOR + supertype_factor))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="supertype_expression")) + inverse_clause << (((INVERSE + inverse_attr + ZeroOrMore(inverse_attr)))).setParseAction(AttributeList) + aggregate_initializer << (((CaselessLiteral("[") + Optional((element + ZeroOrMore((CaselessLiteral(",") + element)))) + CaselessLiteral("]")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="aggregate_initializer")) + return_stmt << (((RETURN + Optional((CaselessLiteral("(") + expression + CaselessLiteral(")"))) + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="return_stmt")) + generalized_types << (((aggregate_type | general_aggregation_types | generic_entity_type | generic_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="generalized_types")) + bound_2 << (numeric_expression) + real_type << (((REAL + Optional((CaselessLiteral("(") + precision_spec + CaselessLiteral(")")))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="real_type")) + index_2 << (index) + array_type << (((ARRAY + bound_spec + OF + Optional(OPTIONAL) + Optional(UNIQUE) + instantiable_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="array_type")) + local_decl << (((LOCAL + local_variable + ZeroOrMore(local_variable) + END_LOCAL + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="local_decl")) + supertype_term << (((one_of | (CaselessLiteral("(") + supertype_expression + CaselessLiteral(")")) | entity_ref))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="supertype_term")) + where_clause << (((WHERE + domain_rule + CaselessLiteral(";") + ZeroOrMore((domain_rule + CaselessLiteral(";")))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="where_clause")) + embedded_remark << (((CaselessLiteral("(*") + Optional(remark_tag) + ZeroOrMore(((not_paren_star + ZeroOrMore(not_paren_star)) | lparen_then_not_lparen_star | (CaselessLiteral("*") + ZeroOrMore(CaselessLiteral("*"))) | not_rparen_star_then_rparen | embedded_remark)) + CaselessLiteral("*)")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="embedded_remark")) + compound_stmt << (((BEGIN + stmt + ZeroOrMore(stmt) + END + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="compound_stmt")) + bound_1 << (numeric_expression) + alias_stmt << (((ALIAS + variable_id + FOR + general_ref + ZeroOrMore(qualifier) + CaselessLiteral(";") + stmt + ZeroOrMore(stmt) + END_ALIAS + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="alias_stmt")) + subtype_constraint << (((OF + CaselessLiteral("(") + supertype_expression + CaselessLiteral(")")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subtype_constraint")) + string_type << (((STRING + Optional(width_spec)))).setParseAction(StringType) + function_decl << (((function_head + algorithm_head + stmt + ZeroOrMore(stmt) + END_FUNCTION + CaselessLiteral(";")))).setParseAction(FunctionDeclaration) + general_list_type << (((LIST + Optional(bound_spec) + OF + Optional(UNIQUE) + parameter_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="general_list_type")) + supertype_factor << (((supertype_term + ZeroOrMore((AND + supertype_term))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="supertype_factor")) + rule_decl << (((rule_head + algorithm_head + ZeroOrMore(stmt) + where_clause + END_RULE + CaselessLiteral(";")))).setParseAction(RuleDeclaration) + qualifiable_factor << (((function_call | attribute_ref | constant_factor | general_ref | population))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="qualifiable_factor")) + bound_spec << (((CaselessLiteral("[") + bound_1 + CaselessLiteral(":") + bound_2 + CaselessLiteral("]")))).setParseAction(BoundSpecification) syntax.ignore("--" + restOfLine) syntax.ignore(Regex(r"\((?:\*(?:[^*]*\*+)+?\))")) diff --git a/src/ifcopenshell-python/ifcopenshell/express/nodes.py b/src/ifcopenshell-python/ifcopenshell/express/nodes.py index 412ff49877..a6d29650f7 100644 --- a/src/ifcopenshell-python/ifcopenshell/express/nodes.py +++ b/src/ifcopenshell-python/ifcopenshell/express/nodes.py @@ -24,6 +24,7 @@ import string import operator import collections +import bootstrap class Node: def __init__(self, s, loc, tokens, rule=None): @@ -57,10 +58,18 @@ class ListNode: self.rule = rule or (type(self).__name__) self.tokens = tokens.asList() self.dict_tokens = collections.defaultdict(list) + + rules_as_list = set() for t in self.tokens: r = getattr(t, 'rule', None) if r: - self.dict_tokens[r].append(t) + rules_as_list.add(r) + self.dict_tokens[r].append(t) + + for r, t in tokens.asDict().items(): + if r not in rules_as_list: + self.dict_tokens[r].append(t) + self.flat = sum([getattr(t, "flat", [t]) for t in self.tokens], []) def __repr__(self): @@ -68,9 +77,10 @@ class ListNode: def __iter__(self): return iter(self.tokens) - - def __getitem__(self, i): - return self.tokens[i] + + # Somehow indexing messes up the pyparsing results, so instead of x[0] use list(x)[0] + # def __getitem__(self, i): + # return self.tokens[i] def init(self): pass @@ -115,7 +125,7 @@ class TypeDeclaration(Node): self.where = [] clause = self.where_clause if clause: - clause = clause[0] + clause = list(clause[0]) self.where = [(r.simple_id, format_clause(r.expression[0])) for r in clause[1::2]] @@ -170,7 +180,7 @@ class EntityDeclaration(Node): self.where = [] clause = [r for r in self.entity_body[0] if r.rule == "where_clause"] if clause: - clause = clause[0] + clause = list(clause[0]) self.where = [(r.simple_id, format_clause(r.expression[0])) for r in clause[1::2]] @@ -178,7 +188,7 @@ class EntityDeclaration(Node): clause = [r for r in self.entity_body[0] if r.rule == "unique_clause"] if clause: clause = clause[0] - self.unique = [(r[0], r[2].simple_id) for r in clause[1::2]] + self.unique = [(r[0], r[2].simple_id) for r in map(list, list(clause)[1::2])] def __repr__(self): strm = io.StringIO() @@ -222,7 +232,7 @@ class EntityDeclaration(Node): class EnumerationType(Node): - values = property(lambda self: self.enumeration_type[2][1::2]) + values = property(lambda self: list(self.enumeration_type[2])[1::2]) def __repr__(self): return "ENUMERATION OF (" + ",".join(self.values) + ")" @@ -241,29 +251,160 @@ def do_try(fn): except: pass +def get_rule_id(x): + if not isinstance(x, str): + x = type(x).__name__ + matches = [k for k, v in bootstrap.actions.items() if v == x] + if matches: + return matches[0] + +rule_dependencies = { + k: list(map(operator.attrgetter('contents'), bootstrap.reduce(lambda x, y: x | y, (bootstrap.find_bytype(e, bootstrap.Keyword) for e in [v])))) \ + for k, v in bootstrap.express +} + +all_rules = [k for k, e in bootstrap.express] + +rule_definitions = {k: v for k, v in bootstrap.express} + def to_tree(x, key=None): - def get_rule_id(x): - from bootstrap import actions - ty = type(x).__name__ - matches = [k for k, v in actions.items() if v == ty] - if matches: - return matches[0] def prune(di): - import bootstrap - rule_dependencies = { - k: list(map(operator.attrgetter('contents'), bootstrap.reduce(lambda x, y: x | y, (bootstrap.find_bytype(e, bootstrap.Keyword) for e in [v])))) \ - for k, v in bootstrap.express - } - subrules = list(filter(str.islower, rule_dependencies[key])) - return {k: v for k, v in di.items() if k in subrules} + # translate class names back to grammar rules if nested actions are encountered + di = {get_rule_id(k) or k: v for k, v in di.items()} + + def replace_synonyms(x): + for y in x: + yield y + if False: # y in di: + # production element from grammar is found in parsed data, + # return that. + + # we now always explore other synonym, because more often than not we loose data otherwise + yield y + else: + # lookup rule + rule = [e for k, e in bootstrap.express if k == y][0] + + def is_synonym(rl): + if isinstance(rl, bootstrap.Term) and isinstance(rl.contents, bootstrap.Keyword): + return rl.contents.contents + + # is this a synonym? then processs that + if S := is_synonym(rule): + yield S + # Do this recursively + yield from replace_synonyms([S]) + + # is this a concatenation with zero or more synonyms? then also processs that + # @todo catches: + # - simple_expression = term { add_like_op term } . + # but should probably also work on + # - a = b { b } + # in which case the second Concat would be eliminated + elif isinstance(rule, bootstrap.Concat) and \ + len(rule.contents) == 2 and \ + is_synonym(rule.contents[0]) and \ + isinstance(rule.contents[1].contents, bootstrap.Repeated) and \ + isinstance(rule.contents[1].contents.contents[0], bootstrap.Concat) and \ + str(rule.contents[1].contents.contents[0].contents[1]) == str(rule.contents[0]): + S = is_synonym(rule.contents[0]) + yield S + # Do this recursively + yield from replace_synonyms([S]) + + subrules = list(replace_synonyms(rule_dependencies[key])) + + if key == "aggregation_types": + # hack hack hack apparently the parser can't distinguish these + subrules += list(replace_synonyms(rule_dependencies["general_aggregation_types"])) + + if rule_dependencies[key] and not subrules: + # sometimes an intermediate production rule is missing + # from the pyparsing output, e.g from parameter to simple_expression + # directly. Recover from this. + subrules = sum(map(rule_dependencies.__getitem__, rule_dependencies[key]), []) + + if not isinstance(rule_definitions[key], bootstrap.Union): + # Filter out terminals when not a union. E.g no + # reason to retain TYPE, END_TYPE, but operators + # such as IN, LIKE should be retained. + subrules = list(filter(str.islower, subrules)) + + vs = list(di.values()) + + return {k: v for k, v in di.items() if k in subrules or (k == key and len(vs) == 1 and vs[0] not in all_rules)} + + def simplify(di): + if isinstance(di, list): + if set(map(type, di)) == {str} and set(map(len, di)) == {1}: + return "".join(di) + return [simplify(v) for v in di] + elif isinstance(di, dict) and len(di) == 1 and next(iter(di.values())) == {}: + return next(iter(di.keys())) + elif isinstance(di, dict): + return {k: simplify(v) for k, v in di.items()} + else: + return di if isinstance(x, ListNode): - return to_tree(x.dict_tokens, key=get_rule_id(x) or key) - if isinstance(x, Node,): - return to_tree(x.tokens, key=get_rule_id(x) or key) + d = to_tree(x.dict_tokens, key=get_rule_id(x) or key) + + if key == 'if_stmt': + # The definition of if statement if (roughy): + # 'if' expr 'then' stmt+ 'else' stmt+ + # this causes stmt to be joined under the same + # dict key. The code below creates an artifical + # `else_stmt` that collects the second group + # of stmts. + + statements = x.dict_tokens['stmt'] + + else_index = None + if_nesting = 0 + for i, tk in enumerate(x.flat): + if tk == 'if': if_nesting += 1 + if tk == 'end_if': if_nesting -= 1 + if tk == 'else' and if_nesting == 1: + else_index = i + + if else_index: + indices = [] + for s in statements: + for i in range(max(indices, default=0), len(x.flat)): + if x.flat[i:i+len(s.flat)] == s.flat: + indices.append(i) + break + + assert len(indices) == len(statements) + before_else = [i < else_index for i in indices] + + else_stmt = [st for b, st in zip(before_else, d['stmt']) if not b] + d['stmt'] = [st for b, st in zip(before_else, d['stmt']) if b] + + if else_stmt: + d['else_stmt'] = else_stmt + + if key == 'formal_parameter': + # Not so pretty hack to fix the overwriting of simple_id-like + # ast nodes. The full solution would probably to register parse + # actions. And directly reassign. + pid = d['parameter_id'][0][0] + d['parameter_id'][0] = x.flat[:x.flat.index(pid)+1:2] + + if key is None: + return {get_rule_id(x): d} + return d + elif isinstance(x, Node): + d = to_tree(x.tokens, key=get_rule_id(x) or key) + if key is None: + return {get_rule_id(x): d} + return d elif isinstance(x, dict): - return prune({k: to_tree(v, key=k) for k, v in x.items()}) + # d = {k: to_tree(v, key=k) for k, v in x.items()} + # not fully understood, but when finding specific node Types and production rules, prioritize the former + d = {get_rule_id(k) or k: to_tree(v, key=k) for k, v in sorted(x.items(), key=lambda p: get_rule_id(p[0]) is not None)} + return simplify(prune(d)) elif isinstance(x, list): return [to_tree(v, key=key) for v in x] else: @@ -306,7 +447,7 @@ class AggregationType(Node): class SelectType(Node): - values = property(lambda self: self.select_type[1][1::2]) + values = property(lambda self: list(self.select_type[1])[1::2]) def __repr__(self): return "SELECT (" + ",".join(map(str, self.values)) + ")" @@ -321,7 +462,7 @@ class SuperTypeExpression(Node): else: constraint = self.supertype_rule[0] return [ - s[0][0].simple_id for s in constraint.subtype_constraint[0].supertype_expression[0][0][0].one_of[0][2::2] + list(list(s)[0])[0].simple_id for s in list(list(list(constraint.subtype_constraint[0].supertype_expression[0])[0])[0].one_of[0])[2::2] ] sub_types = property(get_sub_types) @@ -418,7 +559,7 @@ class WidthSpec(Node): fixed = property(lambda self: self.FIXED is not None) def init(self): - self.width = int("".join(self.width[0].flat)) + self.width = int("".join(list(self.width)[0].flat)) def __repr__(self): return "(%d)%s" % (self.width, " fixed" if self.fixed else "") @@ -432,3 +573,16 @@ class StringType(Node): if self.width: s += " " + repr(self.width) return s + + +class ProcedureDeclaration(ListNode): + @property + def name(self): + return self.flat[1] + + +class FunctionDeclaration(ProcedureDeclaration): + pass + +class RuleDeclaration(ProcedureDeclaration): + pass diff --git a/src/ifcopenshell-python/ifcopenshell/express/rule_compiler.py b/src/ifcopenshell-python/ifcopenshell/express/rule_compiler.py new file mode 100644 index 0000000000..990608d792 --- /dev/null +++ b/src/ifcopenshell-python/ifcopenshell/express/rule_compiler.py @@ -0,0 +1,703 @@ +import os +import re +import sys +import json +import hashlib +import operator +import functools +import itertools + +import ifcopenshell.express + +import networkx as nx + +from codegen import indent + +DEBUG = False + +def to_graph(tree): + g = nx.DiGraph() + + # Convert + def write_to_graph(val, name=None): + if isinstance(val, list): + pairs = ((None, v) for v in val) + elif isinstance(val, dict): + pairs = val.items() + else: + assert name + g.add_edge(name, name + "_value") + return g.add_node(name + "_value", label=val) + + for i, (k, v) in enumerate(pairs): + i = f"{i:03d}" + nid = f"{name or 'root'}_{k or i}" + g.add_node(nid, label=k) + if name: + g.add_edge(name, nid) + write_to_graph(v, nid) + + write_to_graph(tree) + + to_remove = set() + + # Remove intermediate anonymous nodes. Often the result of ZeroOrMore() productions in + # bootstrap.py that result in an intermediate list index node in to_tree() + + # Start with the intermediate nodes and filter out root (needs to have predecessors) + intermediate = [n for n in g.nodes if g.nodes[n].get('label') is None and list(g.predecessors(n))] + + for n in intermediate: + pr = list(g.predecessors(n)) + if len(pr) == 1 and g.nodes[pr[0]].get('label'): + # when eliminating a grouping node with heterogeneous content + # rather copy the predecessor node label to the grouping node + # and later delete the predecessor + sc = list(g.successors(n)) + if len(sc) > 1: + sc_labels = list(map(lambda x: g.nodes[x].get('label'), sc)) + if len(set(sc_labels)) > 1 and None not in sc_labels: + g.nodes[n]['label'] = g.nodes[pr[0]].get('label') + to_remove.add(pr[0]) + continue + + for ab in itertools.product(g.predecessors(n), g.successors(n)): + g.add_edge(*ab) + g.remove_node(n) + + # The removal process above can decide to not fold the anonymous node, but rather + # the predecessor of it, in which case it is deleted in this step. + for n in to_remove: + for ab in itertools.product(g.predecessors(n), g.successors(n)): + g.add_edge(*ab) + g.remove_node(n) + + for n in g.nodes: + if len(list(g.successors(n))) == 0 and g.nodes[n].get('label') not in ifcopenshell.express.express_parser.all_rules: + g.nodes[n]['is_terminal'] = True + + return g + +def write_dot(fn, g): + + with open(fn, "w") as f: + + def w(*args, **kwargs): + print(*args, file=f, **kwargs) + + w("digraph", "{") + + def nodename(n): + return "N"+hashlib.md5(n.encode()).hexdigest() + + def format(di): + Q = '"' + inner = ",".join(f"{k}={'' if v.startswith('<') else Q}{v}{'' if v.startswith('<') else Q}" for k, v in di.items()) + if inner: + inner = f"[{inner}]" + return inner + + for n in g.nodes: + lbl = g.nodes[n].get('label') + if lbl: + attrs = {"label": lbl} + else: + attrs = {"label": n} + + if g.nodes[n].get('is_terminal'): + attrs["shape"] = "rect" + attrs["label"] = f"\\\"{attrs['label']}\\\"" + else: + attrs["shape"] = "none" + + w(nodename(n), format(attrs), ";", sep="") + + for a,b in g.edges: + w(nodename(a), "->", nodename(b), ";") + + w("}", flush=True) + + +from pyparsing import * +SLASH = Suppress("/") +identifier = Word(alphanums + "_") +rule = identifier + (ZeroOrMore(SLASH + identifier)) + +def paths(G, root, length): + if length == 1: + yield (G.nodes[root].get('label'),) + return + + sd = dict(nx.bfs_successors(G, root, depth_limit=length-1)) + def r(x, p=None): + if p and len(p) == length: + yield tuple(map(lambda n: G.nodes[n].get('label'), p)) + else: + for y in sd.get(x, []): + yield from r(y, (p or [x])+[y]) + yield from r(root) + + +class context: + def __init__(self, graph, rules): + self.graph = graph + self.rules = rules + + def __getattr__(self, k): + def inner(): + for r in self.rules: + label_id_pairs = map( + lambda n: (self.graph.nodes[n].get('label'), n), + # itertools.chain.from_iterable( + # dict(nx.bfs_successors(self.graph, r)).values() + # ) + self.graph.successors(r) + ) + matching = filter(lambda p: p[0] == k, label_id_pairs) + yield from map(operator.itemgetter(1), matching) + + return context(self.graph, list(inner())) + + def has_inverse(self, a): + for r in self.rules: + if a in map( + lambda n: self.graph.nodes[n].get('label'), + self.graph.predecessors(r) + ): + return True + return False + + def __iter__(self): + for r in self.rules: + yield context(self.graph, [r]) + + def descendants(self): + return [b.rules[0][len(self.rules[0])+1:] for b in self.branches(allow_multiple=True)] + + def __repr__(self): + try: + s = "\n\n"+str(self) + except: + s = "" + return f"{s}" + + def __str__(self): + assert len(self.rules) == 1 + nodes = itertools.chain(self.rules, itertools.chain.from_iterable( + dict(nx.bfs_successors(self.graph, self.rules[0])).values() + )) + terminals_or_values = list(filter( + lambda n: self.graph.nodes[n].get('is_terminal') or self.graph.nodes[n].get('value'), + nodes + )) + # assert len(terminals) == 1 + attrs = [self.graph.nodes[tv] for tv in terminals_or_values] + attrs = [a.get('value', a['label']) for a in attrs] + attr_types = list(map(type, attrs)) + if empty in attr_types[0:1]: + return "" + attrs = list(filter(lambda s: isinstance(s, str), attrs)) + return attrs[0] + + + def __eq__(self, other): + return self.graph == other.graph and self.rules == other.rules + + + def __hash__(self): + return hash(self.rules) + + + def branches(self, allow_multiple=False, exclude=()): + if not allow_multiple: + assert len(self.rules) == 1 + combined = sum([sorted((context(self.graph, [n]) for n in self.graph.successors(R)), key=lambda c: c.rules[0] if c.rules else "") for R in self.rules], []) + return [c for c in combined if c not in exclude] + + def parent(self): + assert len(self.rules) == 1 + return context(self.graph, list(self.graph.predecessors(self.rules[0]))) + + def branch(self, i): + return self.branches()[i] + + def __len__(self): + return len(self.rules) + + def __getitem__(self, k): + return list(self)[k] + + +# @todo +context_class = context + +class codegen_rule: + def __init__(self, pattern, fn): + self.pattern = tuple(rule.parseString(pattern)) + self.fn = fn + if not hasattr(codegen_rule, 'all_rules'): + codegen_rule.all_rules = [] + codegen_rule.all_rules.append(self) + + def __call__(self, graph, node): + # try: + v = self.fn(context(graph, [node])) + # except: + # v = "ERROR!!" + graph.nodes[node]['value'] = v + return v + + @staticmethod + def apply(G): + v = None + for n in reversed(list(nx.topological_sort(G))): + for r in codegen_rule.all_rules: + if r.pattern in paths(G, n, len(r.pattern)): + v = r(G, n) + return v + +def process_rule_decl(context): + return f""" +class {context.rule_head.rule_id}: + SCOPE = "file" + + @staticmethod + def __call__(file): + {context.rule_head.entity_ref} = file.by_type("{context.rule_head.entity_ref}") +{indent(8, context.algorithm_head.local_decl)} +{indent(8, context.stmt.branches()) if context.stmt else ''} +{indent(8, context.where_clause.domain_rule)} +""" + +class empty: + pass + +wb = r"\b" + +def process_type_decl(scope, context): + class_name = context.type_id if scope == 'type' else context.entity_head.entity_id + + attributes = [] + + if scope == 'entity': + + def get_attributes(nm): + ent = schema.entities[nm] + if ent.supertypes: + yield from get_attributes(ent.supertypes[0]) + yield from [a.name for a in ent.attributes] + yield from [a.name for a in ent.inverse] + # redeclared do not need to be printed, because they're emitted + # as part of supertype + yield from [a[0] for a in ent.derive if isinstance(a[0], str)] + + # @todo derived and inverse attributes + attributes = list(get_attributes(class_name)) + + def format_rule(domain_rule): + return f""" +class {class_name}_{domain_rule.rule_label_id}: + SCOPE = "{scope}" + TYPE_NAME = "{class_name}" + RULE_NAME = "{domain_rule.rule_label_id}" + + @staticmethod + def __call__(self): +{indent(8, (f"{a.lower()} = self.{a}" for a in attributes if re.search(f'{wb}{a.lower()}{wb}', str(domain_rule))))} +{indent(8, domain_rule)} +""" + + rule_parent = context if scope == 'type' else context.entity_body + + statements = [] + + if rule_parent.where_clause: + # @todo should we not try to maintain a 1-1 correspondence? + statements.extend(map(format_rule, rule_parent.where_clause.branches())) + + if scope == 'entity': + def format_derived(derived_attr): + slash = "\\" + return f""" +def calc_{class_name}_{str(derived_attr.attribute_decl.redeclared_attribute.qualified_attribute.attribute_qualifier)[1:] if derived_attr.attribute_decl.redeclared_attribute else derived_attr.attribute_decl}(self): +{indent(4, (f"{a.lower()} = self.{a}" for a in attributes if re.search(f'{wb}{a.lower()}{wb}', str(derived_attr.expression))))} +{indent(4, f"return {slash}")} +{indent(4, derived_attr.expression)} +""" + if context.entity_body.derive_clause: + statements.extend(map(format_derived, context.entity_body.derive_clause.branches())) + + return "\n\n".join(statements) + +def process_domain_rule(context): + return f""" +assert {context.expression} +""" + +def process_expression(context): + def wrap(s): + s = str(s) + if " " in s: + s = '(%s)' % s + return s + + def concat(a, b, **kwargs): + return " ".join(map(str, sum(zip( + [None] + a.branches(**kwargs), + map(wrap, b.branches(**kwargs)) + ), ())[1:])) + + if context.rel_op_extended: + if context.term: + # IfcSameValue + return concat(context.rel_op_extended, context, allow_multiple=True, exclude=[context.rel_op_extended]) + else: + return concat(context.rel_op_extended, context.simple_expression) + elif context.multiplication_like_op: + if str(context.multiplication_like_op.branches()[0]) == '||': + all_args = {} + most_concrete_type = None + most_concrete_type_inheritance_chain_length = -1 + + for s in context.factor.branches(): + typename, args = str(s).split('(', 1) + args = args[:-1] + + break_points = [[0]] + bracket_nesting = 0 + for i, tk in enumerate(args): + if tk in '[(': bracket_nesting += 1 + if tk in ')]': bracket_nesting -= 1 + if tk == ',' and bracket_nesting == 0: + break_points[-1].append(i) + break_points.append([i+1]) + + break_points[-1].append(len(args)) + + S = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema.name) + entity = S.declaration_by_name(typename) + entity_attributes = entity.attributes() + + def count_chain_length(ent): + length = 0 + while ent: + ent = ent.supertype() + length += 1 + return length + + args = [args[slice(*x)] for x in break_points] + + for i, arg in filter(lambda p: p[1], enumerate(args)): + all_args[entity_attributes[i].name()] = arg + + cl = count_chain_length(entity) + if cl > most_concrete_type_inheritance_chain_length: + most_concrete_type = entity.name() + most_concrete_type_inheritance_chain_length = cl + + return f"{most_concrete_type}({', '.join(f'{a[0]}={a[1]}' for a in all_args.items())})" + else: + return concat(context.multiplication_like_op, context.factor) + elif context.add_like_op: + if context.factor or len(context.term) > 1: + # @todo now sure why this is required (in IfcCrossProduct) + # @todo not sure what's going on here, why we have both factor and term as direct child productions of simple_expression (in IfcDotProduct) + return concat(context.add_like_op, context, allow_multiple=True, exclude=[context.add_like_op]) + else: + return concat(context.add_like_op, context.term) + + +def process_interval(context): + op0, op1 = context.interval_op.branches() + return " ".join(map(str, ( + context.interval_low, + op0, + context.interval_item, + op1, + context.interval_high + ))) + + +def simple_concat(context): + # simple_factor: + # only to join unary op (-) with number literal + # primary: + # only to join index with qualifyable operand + + def qualifier_position(s): + # @todo this is a really ugly hack, can we not depend on stable branch order and why? + + # unary operators + if s in ("-", "+", "not"): return -1 + + # qualifiers + if s and s[0] in ('.', '['): return 1 + + # default + return 0 + + branches = sorted(map(str, context.branches()), key=qualifier_position) + + # sorting no longer necessary as we sort in branches() now + # correction: still necessary, apparently. + # branches = list(map(str, context.branches())) + + concat = "" + if len(branches) == 2 and branches[0] == 'not': + concat = " " + + v = concat.join(branches) + + return v + + +def process_rel_op(context): + # @todo the distinction between value comparison and instance comparison + if str(context) == "<>" or str(context) == ":<>:": + return "!=" + elif str(context) == "=" or str(context) == ":=:": + return "==" + + +def process_if_stmt(context): + s = f"if {context.logical_expression if context.logical_expression.branches() else context.expression}:\n{indent(4, context.stmt.branches())}" + if context.else_stmt: + s += f"\nelse:\n{indent(4, context.else_stmt.branches())}" + return s + + +def process_repeat_stmt(context): + ic = context.repeat_control.increment_control + return f"for {ic.variable_id} in range({ic.bound_1}, {ic.bound_2} + 1):\n{indent(4, context.stmt.branches())}" + + +def process_function_decl(context): + arguments = map(str.lower, map(str, context.function_head.formal_parameter.parameter_id.branches(allow_multiple=True))) + return f"def {context.function_head.function_id}({', '.join(arguments)}):\n{indent(4, context.algorithm_head.local_decl)}\n{indent(4, context.stmt.branches())}" + +def process_query(context): + return f"[{str(context.variable_id).lower()} for {str(context.variable_id).lower()} in {context.aggregate_source} if {context.logical_expression if context.logical_expression and context.logical_expression.branches() else context.expression}]" + +def process_local_variable(context): + if context.expression: + expr = str(context.expression) + if context.parameter_type.generalized_types.general_aggregation_types.general_set_type: + expr = re.sub('(\[[^\]]*\])', 'express_set(\\1)', expr) + + return '%s = %s' % (str(context.variable_id).lower(), expr) + else: + return empty() + + +def process_function_call(context): + nm = f"{context.built_in_function if context.built_in_function else context.function_ref}" + args = f"{context.actual_parameter_list if context.actual_parameter_list and context.actual_parameter_list.branches() else ''}" + if nm == "exists" and '[' in args: + # exists check if it receives a callable to catch IndexError, because express semantics + # dictate that out of bounds index returned unknown (IfcTypeObject_WR1) + wrap = "lambda: " + else: + wrap = "" + return f"{nm}({wrap}{args})" + + +def make_lowercase(context): + return str(context).lower() + + +def make_lowercase_if(fn): + def inner(context): + if fn(context): + return make_lowercase(context) + return inner + + +def process_assignment(context): + lhs = str(context.general_ref) + if context.qualifier: + lhs += str(context.qualifier) + if m := re.match(r'^([^\[]+)\[([^\[]+)\]$', lhs): + # @todo ugly regex hack + aggr, index = m.groups() + return f"temp = list({aggr})\ntemp[{index}] = {context.expression}\n{aggr} = temp" + else: + return '%s = %s' % (lhs, context.expression) + +def process_case_action(context): + first = context.parent().branches().index(context) + pred = "elif" if first else "if" + if re.match(r"^'[a-z0-9]+'$", str(context.expression)): + # @todo this is yet again an ugly hack + lower = '.lower()' + else: + lower = '' + return f"{pred} {context.parent().expression}{lower} == {context.expression}:\n{indent(4, context.stmt.branches())}" + + +def process_case_statement(context): + branches = context.branches(exclude=[getattr(context, v) for v in context.descendants() if not v.startswith('case_action')]) + if context.stmt and context.stmt.branches(): + branches += [f"else:\n{indent(4, context.stmt)}"] + return'\n'.join(map(str, branches)) + + +def process_aggregate_initializer(context): + if context.element.repetition: + return '([%s] * %s)' % (context.element.expression, context.element.repetition) + else: + return '[%s]' % ','.join(map(str, context.element.branches() if context.element else ())) + +# implemented sizeof() function in generated code +# codegen_rule("built_in_function/SIZEOF", lambda context: f"len") +# @todo +codegen_rule("function_call", process_function_call) +codegen_rule("actual_parameter_list", lambda context: ','.join(map(str, context.expression.branches() if context.expression else []))) +codegen_rule("entity_decl", functools.partial(process_type_decl, 'entity')) +codegen_rule("rule_decl", process_rule_decl) +codegen_rule("type_decl", functools.partial(process_type_decl, 'type')) +codegen_rule("function_decl", process_function_decl) +codegen_rule("domain_rule", process_domain_rule) +codegen_rule("expression", process_expression) +codegen_rule("simple_expression", process_expression) +codegen_rule("logical_expression", process_expression) +codegen_rule("term", process_expression) +codegen_rule("query_expression", process_query) +codegen_rule("aggregate_initializer", process_aggregate_initializer) +codegen_rule("interval", process_interval) +codegen_rule("simple_factor", simple_concat) +codegen_rule("primary", simple_concat) +codegen_rule("qualifier", simple_concat) +codegen_rule("return_stmt", lambda context: 'return %s' % context) +codegen_rule("compound_stmt", lambda context: '\n'.join(map(str, context.stmt.branches()))) +codegen_rule("if_stmt", process_if_stmt) +codegen_rule("repeat_stmt", process_repeat_stmt) +# codegen_rule("index", lambda context: '**express_index(%s)' % context) +codegen_rule("index", lambda context: '[%s - 1]' % context) +codegen_rule("group_qualifier", lambda context: empty()) +codegen_rule("attribute_qualifier", lambda context: '.%s' % context) +codegen_rule("rel_op", process_rel_op) +codegen_rule("built_in_constant", lambda context: "None" if str(context) == "?" else str(context)) +codegen_rule("assignment_stmt", process_assignment) +codegen_rule("local_variable", process_local_variable) +codegen_rule("local_decl", lambda context: '\n'.join(map(str, context.branches()))) +codegen_rule("general_ref/parameter_ref", make_lowercase) +codegen_rule("qualifiable_factor/attribute_ref", make_lowercase_if(lambda context: str(context) not in set(map(str, schema.all_declarations.keys())))) +codegen_rule("case_action", process_case_action) +codegen_rule("case_stmt", process_case_statement) +codegen_rule("escape_stmt", lambda context: "break") + +codegen_rule("XOR", lambda context: "^") +codegen_rule("MOD", lambda context: "%") +codegen_rule("TRUE", lambda context: "True") +codegen_rule("FALSE", lambda context: "False") + +if __name__ == "__main__": + import sys + import shutil + import subprocess + + schema = ifcopenshell.express.express_parser.parse(sys.argv[1]).schema + ofn = os.path.join(os.path.dirname(__file__), "rules", f"{schema.name}.py") + output = open(ofn, "w") + + print("import ifcopenshell", file=output, sep='\n') + + print(""" +def exists(v): + if callable(v): + try: return v() is not None + except IndexError as e: return False + else: return v is not None +""", "\n", file=output, sep='\n') + print("def nvl(v, default): return v if v is not None else default", "\n", file=output, sep='\n') + + print("sizeof = len", file=output, sep='\n') + print("hiindex = len", file=output, sep='\n') + print("blength = len", file=output, sep='\n') + print("loindex = lambda x: 1", file=output, sep='\n') + print("from math import *", file=output, sep='\n') + + # @todo this will get us in trouble when evaluating the truthness + print("unknown = 'UNKNOWN'", file=output, sep='\n') + + print(""" +def usedin(inst, ref_name): + if inst is None: + return [] + _, __, attr = ref_name.split('.') + def filter(): + for ref, attr_idx in inst.wrapped_data.file.get_inverse(inst, allow_duplicate=True, with_attribute_indices=True): + if ref.wrapped_data.get_attribute_names()[attr_idx].lower() == attr: + yield ref + return list(filter()) + + +class express_set(set): + def __rmul__(self, other): + return express_set(set(other) & self) + def __add__(self, other): + def make_list(v): + # Comply with 12.6.3 Union operator + if isinstance(v, (list, tuple, set, express_set)): + return list(v) + else: + return [v] + return express_set(list(self) + make_list(other)) + __radd__ = __add__ + def __repr__(self): + return repr(set(self)) + + +def typeof(inst): + if not inst: + # If V evaluates to indeterminate (?), an empty set is returned. + return express_set([]) + schema_name = inst.is_a(True).split('.')[0].lower() + def inner(): + decl = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(inst.is_a()) + while decl: + yield '.'.join((schema_name, decl.name().lower())) + decl = decl.supertype() + return express_set(inner()) +""", file=output, sep='\n') + + print("class enum_namespace:\n def __getattr__(self, k):\n return k.upper()", "\n", file=output, sep='\n') + + for k, v in schema.enumerations.items(): + print(f"{k} = enum_namespace()", "\n", file=output, sep='\n') + + for vi in v.values: + print(f"{vi.lower()} = {k}.{vi}", "\n", file=output, sep='\n') + + for k in schema.entities.keys(): + print(f"def {k}(*args, **kwargs): return ifcopenshell.create_entity({k!r}, {schema.name!r}, *args, **kwargs)", "\n", file=output, sep='\n') + + for nm in schema.all_declarations.keys(): + print(nm) + + tree = ifcopenshell.express.express_parser.to_tree(schema[nm]) + + if DEBUG: + with open(f"{nm}.json", "w") as f: + json.dump(tree, f, indent=2) + + G = to_graph(tree) + rule_code = codegen_rule.apply(G) + + if DEBUG: + for n in G.nodes.values(): + if v := n.get('value'): + if isinstance(v, str): + nl = "\n" + es = "\\n" + n['label'] = f'<
{n.get("label")}
{v.replace("<", "<").replace(">", ">").replace(nl, "
")}
>' + elif isinstance(v, empty): + n['label'] = f'<
{n.get("label")}
---
>' + + fn = f"{nm}.dot" + write_dot(fn, G) + subprocess.call([shutil.which("dot") or "dot", fn, "-O", "-Tpng"]) + + print(rule_code, "\n", file=output, sep='\n') + + output.close() diff --git a/src/ifcopenshell-python/ifcopenshell/express/rule_executor.py b/src/ifcopenshell-python/ifcopenshell/express/rule_executor.py new file mode 100644 index 0000000000..37ed255989 --- /dev/null +++ b/src/ifcopenshell-python/ifcopenshell/express/rule_executor.py @@ -0,0 +1,180 @@ +import os +import ast +import collections + +from dataclasses import dataclass +from _pytest import assertion + +import ifcopenshell +from ifcopenshell.validate import json_logger + +from codegen import indent + +def reverse_compile(s): + return s.strip().replace('len(', 'SIZEOF(').replace('assert ', '') + + +@dataclass +class error(Exception): + rule_name : str + rule_definition : str + violation : str + instance : ifcopenshell.entity_instance = None + + def __str__(self): + inst = "" + if self.instance: + inst = f"On instance:\n{indent(4, str(self.instance))}\n" + return f"{inst}Rule {self.rule_name}:\n{indent(4, self.rule_definition)}\nViolated by:\n{indent(4, self.violation)}" + + +def fix_type(v): + if isinstance(v, (list, tuple)): + # 1-based indexing: + # + # @todo this is not the best way, because it still allows to index the 0-th element, + # but given the existing body of rules this should be sufficient. + # return type(v)([None]) + type(v)(map(fix_type, v)) + + # We don't do this anymore, because it doesn't fix instance attribute lookups + # We now instead perform a -1 on the index qualifier in the code generation + pass + # @todo enrich entity instances with code to evaluate derived attributes + return v + + +def run(f, logger): + fn = os.path.join(os.path.dirname(__file__), "rules", f"{f.schema}.py") + source = open(fn, "r").read() + a = ast.parse(source) + assertion.rewrite.rewrite_asserts(mod=a, source=source) + cd = compile(a, f"{f.schema}.py", 'exec') + scope = {} + exec(cd, scope) + S = ifcopenshell.ifcopenshell_wrapper.schema_by_name(f.schema) + + rules = list(filter(lambda x: hasattr(x, 'SCOPE'), scope.values())) + + for R in [r for r in rules if r.SCOPE == 'file']: + try: + R()(f) + except Exception as e: + ln = e.__traceback__.tb_next.tb_lineno + logger.error(str(error( + R.__name__, + reverse_compile(source.split("\n")[ln-1]), + reverse_compile(e.args[0]) + ))) + + types = {} + subtypes = collections.defaultdict(list) + for d in S.declarations(): + if isinstance(d, ifcopenshell.ifcopenshell_wrapper.type_declaration): + types[d.name()] = d + if isinstance(d.declared_type(), ifcopenshell.ifcopenshell_wrapper.named_type): + subtypes[d.declared_type().declared_type().name()].append(d.name()) + + D = collections.defaultdict(list) + for r in rules: + if r.SCOPE == 'type': + def visit(nm): + D[nm].append(r) + for nm2 in subtypes[nm]: + visit(nm2) + visit(r.TYPE_NAME) + + def type_name(ty): + if isinstance(ty, ifcopenshell.ifcopenshell_wrapper.named_type): + return type_name(ty.declared_type()) + elif isinstance(ty, ifcopenshell.ifcopenshell_wrapper.aggregation_type): + # breakpoint() + pass + elif isinstance(ty, ifcopenshell.ifcopenshell_wrapper.simple_type): + pass + else: + return ty.name() + + def check(value, type, instance): + if value is None: + return + + if type_name(type) in D: + for R in D[type_name(type)]: + try: + R()(fix_type(value)) + except Exception as e: + ln = e.__traceback__.tb_next.tb_lineno + logger.error(str(error( + R.__name__, + reverse_compile(source.split("\n")[ln-1]), + reverse_compile(e.args[0]), + instance + ))) + + # @nb something can be a named type with rules and still be an aggregation. + # case in point IfcCompoundPlaneAngleMeasure. Therefore only unpack named + # type references from this point onwards. + while isinstance(type, (ifcopenshell.ifcopenshell_wrapper.named_type, ifcopenshell.ifcopenshell_wrapper.type_declaration)): + type = type.declared_type() + + if isinstance(value, (list, tuple)): + assert isinstance(type, ifcopenshell.ifcopenshell_wrapper.aggregation_type) + ty = type.type_of_element() + for v in value: + check(v, ty, instance=inst) + elif isinstance(value, ifcopenshell.entity_instance): + if isinstance(S.declaration_by_name(value.is_a()), ifcopenshell.ifcopenshell_wrapper.entity): + # top level entity instances will be checked on their own + pass + else: + # unpack the type instance + check(value[0], S.declaration_by_name(value.is_a()), instance=inst) + + + for inst in f: + values = list(inst) + entity = S.declaration_by_name(inst.is_a()) + attrs = entity.all_attributes() + for i, (attr, val, is_derived) in enumerate(zip(attrs, values, entity.derived())): + if is_derived: + # @todo + pass + else: + check(val, attr.type_of_attribute(), instance=inst) + + for R in [r for r in rules if r.SCOPE == 'entity']: + for inst in f.by_type(R.TYPE_NAME): + try: + R()(inst) + except Exception as e: + ln = e.__traceback__.tb_next.tb_lineno + logger.error(str(error( + R.__name__, + reverse_compile(source.split("\n")[ln-1]), + reverse_compile(e.args[0]), + inst + ))) + + +if __name__ == "__main__": + import sys + import json + import logging + import ifcopenshell + + filenames = [x for x in sys.argv[1:] if not x.startswith("--")] + flags = set(x for x in sys.argv[1:] if x.startswith("--")) + + for fn in filenames: + if "--json" in flags: + logger = json_logger() + else: + logger = logging.getLogger("validate") + logger.setLevel(logging.DEBUG) + + f = ifcopenshell.open(fn) + + run(f, logger) + + if "--json" in flags: + print("\n".join(json.dumps(x, default=str) for x in logger.statements)) diff --git a/src/ifcopenshell-python/ifcopenshell/express/rules/IFC2X3.py b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC2X3.py new file mode 100644 index 0000000000..68d07b8b0c --- /dev/null +++ b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC2X3.py @@ -0,0 +1,15269 @@ +import ifcopenshell + +def exists(v): + if callable(v): + try: return v() is not None + except IndexError as e: return False + else: return v is not None + + + +def nvl(v, default): return v if v is not None else default + + +sizeof = len +hiindex = len +blength = len +loindex = lambda x: 1 +from math import * +unknown = 'UNKNOWN' + +def usedin(inst, ref_name): + if inst is None: + return [] + _, __, attr = ref_name.split('.') + def filter(): + for ref, attr_idx in inst.wrapped_data.file.get_inverse(inst, allow_duplicate=True, with_attribute_indices=True): + if ref.wrapped_data.get_attribute_names()[attr_idx].lower() == attr: + yield ref + return list(filter()) + + +class express_set(set): + def __rmul__(self, other): + return express_set(set(other) & self) + def __add__(self, other): + def make_list(v): + # Comply with 12.6.3 Union operator + if isinstance(v, (list, tuple, set, express_set)): + return list(v) + else: + return [v] + return express_set(list(self) + make_list(other)) + __radd__ = __add__ + def __repr__(self): + return repr(set(self)) + + +def typeof(inst): + if not inst: + # If V evaluates to indeterminate (?), an empty set is returned. + return express_set([]) + schema_name = inst.is_a(True).split('.')[0].lower() + def inner(): + decl = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(inst.is_a()) + while decl: + yield '.'.join((schema_name, decl.name().lower())) + decl = decl.supertype() + return express_set(inner()) + +class enum_namespace: + def __getattr__(self, k): + return k.upper() + + +IfcActionSourceTypeEnum = enum_namespace() + + +dead_load_g = IfcActionSourceTypeEnum.DEAD_LOAD_G + + +completion_g1 = IfcActionSourceTypeEnum.COMPLETION_G1 + + +live_load_q = IfcActionSourceTypeEnum.LIVE_LOAD_Q + + +snow_s = IfcActionSourceTypeEnum.SNOW_S + + +wind_w = IfcActionSourceTypeEnum.WIND_W + + +prestressing_p = IfcActionSourceTypeEnum.PRESTRESSING_P + + +settlement_u = IfcActionSourceTypeEnum.SETTLEMENT_U + + +temperature_t = IfcActionSourceTypeEnum.TEMPERATURE_T + + +earthquake_e = IfcActionSourceTypeEnum.EARTHQUAKE_E + + +fire = IfcActionSourceTypeEnum.FIRE + + +impulse = IfcActionSourceTypeEnum.IMPULSE + + +impact = IfcActionSourceTypeEnum.IMPACT + + +transport = IfcActionSourceTypeEnum.TRANSPORT + + +erection = IfcActionSourceTypeEnum.ERECTION + + +propping = IfcActionSourceTypeEnum.PROPPING + + +system_imperfection = IfcActionSourceTypeEnum.SYSTEM_IMPERFECTION + + +shrinkage = IfcActionSourceTypeEnum.SHRINKAGE + + +creep = IfcActionSourceTypeEnum.CREEP + + +lack_of_fit = IfcActionSourceTypeEnum.LACK_OF_FIT + + +buoyancy = IfcActionSourceTypeEnum.BUOYANCY + + +ice = IfcActionSourceTypeEnum.ICE + + +current = IfcActionSourceTypeEnum.CURRENT + + +wave = IfcActionSourceTypeEnum.WAVE + + +rain = IfcActionSourceTypeEnum.RAIN + + +brakes = IfcActionSourceTypeEnum.BRAKES + + +userdefined = IfcActionSourceTypeEnum.USERDEFINED + + +notdefined = IfcActionSourceTypeEnum.NOTDEFINED + + +IfcActionTypeEnum = enum_namespace() + + +permanent_g = IfcActionTypeEnum.PERMANENT_G + + +variable_q = IfcActionTypeEnum.VARIABLE_Q + + +extraordinary_a = IfcActionTypeEnum.EXTRAORDINARY_A + + +userdefined = IfcActionTypeEnum.USERDEFINED + + +notdefined = IfcActionTypeEnum.NOTDEFINED + + +IfcActuatorTypeEnum = enum_namespace() + + +electricactuator = IfcActuatorTypeEnum.ELECTRICACTUATOR + + +handoperatedactuator = IfcActuatorTypeEnum.HANDOPERATEDACTUATOR + + +hydraulicactuator = IfcActuatorTypeEnum.HYDRAULICACTUATOR + + +pneumaticactuator = IfcActuatorTypeEnum.PNEUMATICACTUATOR + + +thermostaticactuator = IfcActuatorTypeEnum.THERMOSTATICACTUATOR + + +userdefined = IfcActuatorTypeEnum.USERDEFINED + + +notdefined = IfcActuatorTypeEnum.NOTDEFINED + + +IfcAddressTypeEnum = enum_namespace() + + +office = IfcAddressTypeEnum.OFFICE + + +site = IfcAddressTypeEnum.SITE + + +home = IfcAddressTypeEnum.HOME + + +distributionpoint = IfcAddressTypeEnum.DISTRIBUTIONPOINT + + +userdefined = IfcAddressTypeEnum.USERDEFINED + + +IfcAheadOrBehind = enum_namespace() + + +ahead = IfcAheadOrBehind.AHEAD + + +behind = IfcAheadOrBehind.BEHIND + + +IfcAirTerminalBoxTypeEnum = enum_namespace() + + +constantflow = IfcAirTerminalBoxTypeEnum.CONSTANTFLOW + + +variableflowpressuredependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREDEPENDANT + + +variableflowpressureindependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREINDEPENDANT + + +userdefined = IfcAirTerminalBoxTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalBoxTypeEnum.NOTDEFINED + + +IfcAirTerminalTypeEnum = enum_namespace() + + +grille = IfcAirTerminalTypeEnum.GRILLE + + +register = IfcAirTerminalTypeEnum.REGISTER + + +diffuser = IfcAirTerminalTypeEnum.DIFFUSER + + +eyeball = IfcAirTerminalTypeEnum.EYEBALL + + +iris = IfcAirTerminalTypeEnum.IRIS + + +lineargrille = IfcAirTerminalTypeEnum.LINEARGRILLE + + +lineardiffuser = IfcAirTerminalTypeEnum.LINEARDIFFUSER + + +userdefined = IfcAirTerminalTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalTypeEnum.NOTDEFINED + + +IfcAirToAirHeatRecoveryTypeEnum = enum_namespace() + + +fixedplatecounterflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECOUNTERFLOWEXCHANGER + + +fixedplatecrossflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECROSSFLOWEXCHANGER + + +fixedplateparallelflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATEPARALLELFLOWEXCHANGER + + +rotarywheel = IfcAirToAirHeatRecoveryTypeEnum.ROTARYWHEEL + + +runaroundcoilloop = IfcAirToAirHeatRecoveryTypeEnum.RUNAROUNDCOILLOOP + + +heatpipe = IfcAirToAirHeatRecoveryTypeEnum.HEATPIPE + + +twintowerenthalpyrecoveryloops = IfcAirToAirHeatRecoveryTypeEnum.TWINTOWERENTHALPYRECOVERYLOOPS + + +thermosiphonsealedtubeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONSEALEDTUBEHEATEXCHANGERS + + +thermosiphoncoiltypeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONCOILTYPEHEATEXCHANGERS + + +userdefined = IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED + + +notdefined = IfcAirToAirHeatRecoveryTypeEnum.NOTDEFINED + + +IfcAlarmTypeEnum = enum_namespace() + + +bell = IfcAlarmTypeEnum.BELL + + +breakglassbutton = IfcAlarmTypeEnum.BREAKGLASSBUTTON + + +light = IfcAlarmTypeEnum.LIGHT + + +manualpullbox = IfcAlarmTypeEnum.MANUALPULLBOX + + +siren = IfcAlarmTypeEnum.SIREN + + +whistle = IfcAlarmTypeEnum.WHISTLE + + +userdefined = IfcAlarmTypeEnum.USERDEFINED + + +notdefined = IfcAlarmTypeEnum.NOTDEFINED + + +IfcAnalysisModelTypeEnum = enum_namespace() + + +in_plane_loading_2d = IfcAnalysisModelTypeEnum.IN_PLANE_LOADING_2D + + +out_plane_loading_2d = IfcAnalysisModelTypeEnum.OUT_PLANE_LOADING_2D + + +loading_3d = IfcAnalysisModelTypeEnum.LOADING_3D + + +userdefined = IfcAnalysisModelTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisModelTypeEnum.NOTDEFINED + + +IfcAnalysisTheoryTypeEnum = enum_namespace() + + +first_order_theory = IfcAnalysisTheoryTypeEnum.FIRST_ORDER_THEORY + + +second_order_theory = IfcAnalysisTheoryTypeEnum.SECOND_ORDER_THEORY + + +third_order_theory = IfcAnalysisTheoryTypeEnum.THIRD_ORDER_THEORY + + +full_nonlinear_theory = IfcAnalysisTheoryTypeEnum.FULL_NONLINEAR_THEORY + + +userdefined = IfcAnalysisTheoryTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisTheoryTypeEnum.NOTDEFINED + + +IfcArithmeticOperatorEnum = enum_namespace() + + +add = IfcArithmeticOperatorEnum.ADD + + +divide = IfcArithmeticOperatorEnum.DIVIDE + + +multiply = IfcArithmeticOperatorEnum.MULTIPLY + + +subtract = IfcArithmeticOperatorEnum.SUBTRACT + + +IfcAssemblyPlaceEnum = enum_namespace() + + +site = IfcAssemblyPlaceEnum.SITE + + +factory = IfcAssemblyPlaceEnum.FACTORY + + +notdefined = IfcAssemblyPlaceEnum.NOTDEFINED + + +IfcBSplineCurveForm = enum_namespace() + + +polyline_form = IfcBSplineCurveForm.POLYLINE_FORM + + +circular_arc = IfcBSplineCurveForm.CIRCULAR_ARC + + +elliptic_arc = IfcBSplineCurveForm.ELLIPTIC_ARC + + +parabolic_arc = IfcBSplineCurveForm.PARABOLIC_ARC + + +hyperbolic_arc = IfcBSplineCurveForm.HYPERBOLIC_ARC + + +unspecified = IfcBSplineCurveForm.UNSPECIFIED + + +IfcBeamTypeEnum = enum_namespace() + + +beam = IfcBeamTypeEnum.BEAM + + +joist = IfcBeamTypeEnum.JOIST + + +lintel = IfcBeamTypeEnum.LINTEL + + +t_beam = IfcBeamTypeEnum.T_BEAM + + +userdefined = IfcBeamTypeEnum.USERDEFINED + + +notdefined = IfcBeamTypeEnum.NOTDEFINED + + +IfcBenchmarkEnum = enum_namespace() + + +greaterthan = IfcBenchmarkEnum.GREATERTHAN + + +greaterthanorequalto = IfcBenchmarkEnum.GREATERTHANOREQUALTO + + +lessthan = IfcBenchmarkEnum.LESSTHAN + + +lessthanorequalto = IfcBenchmarkEnum.LESSTHANOREQUALTO + + +equalto = IfcBenchmarkEnum.EQUALTO + + +notequalto = IfcBenchmarkEnum.NOTEQUALTO + + +IfcBoilerTypeEnum = enum_namespace() + + +water = IfcBoilerTypeEnum.WATER + + +steam = IfcBoilerTypeEnum.STEAM + + +userdefined = IfcBoilerTypeEnum.USERDEFINED + + +notdefined = IfcBoilerTypeEnum.NOTDEFINED + + +IfcBooleanOperator = enum_namespace() + + +union = IfcBooleanOperator.UNION + + +intersection = IfcBooleanOperator.INTERSECTION + + +difference = IfcBooleanOperator.DIFFERENCE + + +IfcBuildingElementProxyTypeEnum = enum_namespace() + + +userdefined = IfcBuildingElementProxyTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementProxyTypeEnum.NOTDEFINED + + +IfcCableCarrierFittingTypeEnum = enum_namespace() + + +bend = IfcCableCarrierFittingTypeEnum.BEND + + +cross = IfcCableCarrierFittingTypeEnum.CROSS + + +reducer = IfcCableCarrierFittingTypeEnum.REDUCER + + +tee = IfcCableCarrierFittingTypeEnum.TEE + + +userdefined = IfcCableCarrierFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierFittingTypeEnum.NOTDEFINED + + +IfcCableCarrierSegmentTypeEnum = enum_namespace() + + +cableladdersegment = IfcCableCarrierSegmentTypeEnum.CABLELADDERSEGMENT + + +cabletraysegment = IfcCableCarrierSegmentTypeEnum.CABLETRAYSEGMENT + + +cabletrunkingsegment = IfcCableCarrierSegmentTypeEnum.CABLETRUNKINGSEGMENT + + +conduitsegment = IfcCableCarrierSegmentTypeEnum.CONDUITSEGMENT + + +userdefined = IfcCableCarrierSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierSegmentTypeEnum.NOTDEFINED + + +IfcCableSegmentTypeEnum = enum_namespace() + + +cablesegment = IfcCableSegmentTypeEnum.CABLESEGMENT + + +conductorsegment = IfcCableSegmentTypeEnum.CONDUCTORSEGMENT + + +userdefined = IfcCableSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableSegmentTypeEnum.NOTDEFINED + + +IfcChangeActionEnum = enum_namespace() + + +nochange = IfcChangeActionEnum.NOCHANGE + + +modified = IfcChangeActionEnum.MODIFIED + + +added = IfcChangeActionEnum.ADDED + + +deleted = IfcChangeActionEnum.DELETED + + +modifiedadded = IfcChangeActionEnum.MODIFIEDADDED + + +modifieddeleted = IfcChangeActionEnum.MODIFIEDDELETED + + +IfcChillerTypeEnum = enum_namespace() + + +aircooled = IfcChillerTypeEnum.AIRCOOLED + + +watercooled = IfcChillerTypeEnum.WATERCOOLED + + +heatrecovery = IfcChillerTypeEnum.HEATRECOVERY + + +userdefined = IfcChillerTypeEnum.USERDEFINED + + +notdefined = IfcChillerTypeEnum.NOTDEFINED + + +IfcCoilTypeEnum = enum_namespace() + + +dxcoolingcoil = IfcCoilTypeEnum.DXCOOLINGCOIL + + +watercoolingcoil = IfcCoilTypeEnum.WATERCOOLINGCOIL + + +steamheatingcoil = IfcCoilTypeEnum.STEAMHEATINGCOIL + + +waterheatingcoil = IfcCoilTypeEnum.WATERHEATINGCOIL + + +electricheatingcoil = IfcCoilTypeEnum.ELECTRICHEATINGCOIL + + +gasheatingcoil = IfcCoilTypeEnum.GASHEATINGCOIL + + +userdefined = IfcCoilTypeEnum.USERDEFINED + + +notdefined = IfcCoilTypeEnum.NOTDEFINED + + +IfcColumnTypeEnum = enum_namespace() + + +column = IfcColumnTypeEnum.COLUMN + + +userdefined = IfcColumnTypeEnum.USERDEFINED + + +notdefined = IfcColumnTypeEnum.NOTDEFINED + + +IfcCompressorTypeEnum = enum_namespace() + + +dynamic = IfcCompressorTypeEnum.DYNAMIC + + +reciprocating = IfcCompressorTypeEnum.RECIPROCATING + + +rotary = IfcCompressorTypeEnum.ROTARY + + +scroll = IfcCompressorTypeEnum.SCROLL + + +trochoidal = IfcCompressorTypeEnum.TROCHOIDAL + + +singlestage = IfcCompressorTypeEnum.SINGLESTAGE + + +booster = IfcCompressorTypeEnum.BOOSTER + + +opentype = IfcCompressorTypeEnum.OPENTYPE + + +hermetic = IfcCompressorTypeEnum.HERMETIC + + +semihermetic = IfcCompressorTypeEnum.SEMIHERMETIC + + +weldedshellhermetic = IfcCompressorTypeEnum.WELDEDSHELLHERMETIC + + +rollingpiston = IfcCompressorTypeEnum.ROLLINGPISTON + + +rotaryvane = IfcCompressorTypeEnum.ROTARYVANE + + +singlescrew = IfcCompressorTypeEnum.SINGLESCREW + + +twinscrew = IfcCompressorTypeEnum.TWINSCREW + + +userdefined = IfcCompressorTypeEnum.USERDEFINED + + +notdefined = IfcCompressorTypeEnum.NOTDEFINED + + +IfcCondenserTypeEnum = enum_namespace() + + +watercooledshelltube = IfcCondenserTypeEnum.WATERCOOLEDSHELLTUBE + + +watercooledshellcoil = IfcCondenserTypeEnum.WATERCOOLEDSHELLCOIL + + +watercooledtubeintube = IfcCondenserTypeEnum.WATERCOOLEDTUBEINTUBE + + +watercooledbrazedplate = IfcCondenserTypeEnum.WATERCOOLEDBRAZEDPLATE + + +aircooled = IfcCondenserTypeEnum.AIRCOOLED + + +evaporativecooled = IfcCondenserTypeEnum.EVAPORATIVECOOLED + + +userdefined = IfcCondenserTypeEnum.USERDEFINED + + +notdefined = IfcCondenserTypeEnum.NOTDEFINED + + +IfcConnectionTypeEnum = enum_namespace() + + +atpath = IfcConnectionTypeEnum.ATPATH + + +atstart = IfcConnectionTypeEnum.ATSTART + + +atend = IfcConnectionTypeEnum.ATEND + + +notdefined = IfcConnectionTypeEnum.NOTDEFINED + + +IfcConstraintEnum = enum_namespace() + + +hard = IfcConstraintEnum.HARD + + +soft = IfcConstraintEnum.SOFT + + +advisory = IfcConstraintEnum.ADVISORY + + +userdefined = IfcConstraintEnum.USERDEFINED + + +notdefined = IfcConstraintEnum.NOTDEFINED + + +IfcControllerTypeEnum = enum_namespace() + + +floating = IfcControllerTypeEnum.FLOATING + + +proportional = IfcControllerTypeEnum.PROPORTIONAL + + +proportionalintegral = IfcControllerTypeEnum.PROPORTIONALINTEGRAL + + +proportionalintegralderivative = IfcControllerTypeEnum.PROPORTIONALINTEGRALDERIVATIVE + + +timedtwoposition = IfcControllerTypeEnum.TIMEDTWOPOSITION + + +twoposition = IfcControllerTypeEnum.TWOPOSITION + + +userdefined = IfcControllerTypeEnum.USERDEFINED + + +notdefined = IfcControllerTypeEnum.NOTDEFINED + + +IfcCooledBeamTypeEnum = enum_namespace() + + +active = IfcCooledBeamTypeEnum.ACTIVE + + +passive = IfcCooledBeamTypeEnum.PASSIVE + + +userdefined = IfcCooledBeamTypeEnum.USERDEFINED + + +notdefined = IfcCooledBeamTypeEnum.NOTDEFINED + + +IfcCoolingTowerTypeEnum = enum_namespace() + + +naturaldraft = IfcCoolingTowerTypeEnum.NATURALDRAFT + + +mechanicalinduceddraft = IfcCoolingTowerTypeEnum.MECHANICALINDUCEDDRAFT + + +mechanicalforceddraft = IfcCoolingTowerTypeEnum.MECHANICALFORCEDDRAFT + + +userdefined = IfcCoolingTowerTypeEnum.USERDEFINED + + +notdefined = IfcCoolingTowerTypeEnum.NOTDEFINED + + +IfcCostScheduleTypeEnum = enum_namespace() + + +budget = IfcCostScheduleTypeEnum.BUDGET + + +costplan = IfcCostScheduleTypeEnum.COSTPLAN + + +estimate = IfcCostScheduleTypeEnum.ESTIMATE + + +tender = IfcCostScheduleTypeEnum.TENDER + + +pricedbillofquantities = IfcCostScheduleTypeEnum.PRICEDBILLOFQUANTITIES + + +unpricedbillofquantities = IfcCostScheduleTypeEnum.UNPRICEDBILLOFQUANTITIES + + +scheduleofrates = IfcCostScheduleTypeEnum.SCHEDULEOFRATES + + +userdefined = IfcCostScheduleTypeEnum.USERDEFINED + + +notdefined = IfcCostScheduleTypeEnum.NOTDEFINED + + +IfcCoveringTypeEnum = enum_namespace() + + +ceiling = IfcCoveringTypeEnum.CEILING + + +flooring = IfcCoveringTypeEnum.FLOORING + + +cladding = IfcCoveringTypeEnum.CLADDING + + +roofing = IfcCoveringTypeEnum.ROOFING + + +insulation = IfcCoveringTypeEnum.INSULATION + + +membrane = IfcCoveringTypeEnum.MEMBRANE + + +sleeving = IfcCoveringTypeEnum.SLEEVING + + +wrapping = IfcCoveringTypeEnum.WRAPPING + + +userdefined = IfcCoveringTypeEnum.USERDEFINED + + +notdefined = IfcCoveringTypeEnum.NOTDEFINED + + +IfcCurrencyEnum = enum_namespace() + + +aed = IfcCurrencyEnum.AED + + +aes = IfcCurrencyEnum.AES + + +ats = IfcCurrencyEnum.ATS + + +aud = IfcCurrencyEnum.AUD + + +bbd = IfcCurrencyEnum.BBD + + +beg = IfcCurrencyEnum.BEG + + +bgl = IfcCurrencyEnum.BGL + + +bhd = IfcCurrencyEnum.BHD + + +bmd = IfcCurrencyEnum.BMD + + +bnd = IfcCurrencyEnum.BND + + +brl = IfcCurrencyEnum.BRL + + +bsd = IfcCurrencyEnum.BSD + + +bwp = IfcCurrencyEnum.BWP + + +bzd = IfcCurrencyEnum.BZD + + +cad = IfcCurrencyEnum.CAD + + +cbd = IfcCurrencyEnum.CBD + + +chf = IfcCurrencyEnum.CHF + + +clp = IfcCurrencyEnum.CLP + + +cny = IfcCurrencyEnum.CNY + + +cys = IfcCurrencyEnum.CYS + + +czk = IfcCurrencyEnum.CZK + + +ddp = IfcCurrencyEnum.DDP + + +dem = IfcCurrencyEnum.DEM + + +dkk = IfcCurrencyEnum.DKK + + +egl = IfcCurrencyEnum.EGL + + +est = IfcCurrencyEnum.EST + + +eur = IfcCurrencyEnum.EUR + + +fak = IfcCurrencyEnum.FAK + + +fim = IfcCurrencyEnum.FIM + + +fjd = IfcCurrencyEnum.FJD + + +fkp = IfcCurrencyEnum.FKP + + +frf = IfcCurrencyEnum.FRF + + +gbp = IfcCurrencyEnum.GBP + + +gip = IfcCurrencyEnum.GIP + + +gmd = IfcCurrencyEnum.GMD + + +grx = IfcCurrencyEnum.GRX + + +hkd = IfcCurrencyEnum.HKD + + +huf = IfcCurrencyEnum.HUF + + +ick = IfcCurrencyEnum.ICK + + +idr = IfcCurrencyEnum.IDR + + +ils = IfcCurrencyEnum.ILS + + +inr = IfcCurrencyEnum.INR + + +irp = IfcCurrencyEnum.IRP + + +itl = IfcCurrencyEnum.ITL + + +jmd = IfcCurrencyEnum.JMD + + +jod = IfcCurrencyEnum.JOD + + +jpy = IfcCurrencyEnum.JPY + + +kes = IfcCurrencyEnum.KES + + +krw = IfcCurrencyEnum.KRW + + +kwd = IfcCurrencyEnum.KWD + + +kyd = IfcCurrencyEnum.KYD + + +lkr = IfcCurrencyEnum.LKR + + +luf = IfcCurrencyEnum.LUF + + +mtl = IfcCurrencyEnum.MTL + + +mur = IfcCurrencyEnum.MUR + + +mxn = IfcCurrencyEnum.MXN + + +myr = IfcCurrencyEnum.MYR + + +nlg = IfcCurrencyEnum.NLG + + +nzd = IfcCurrencyEnum.NZD + + +omr = IfcCurrencyEnum.OMR + + +pgk = IfcCurrencyEnum.PGK + + +php = IfcCurrencyEnum.PHP + + +pkr = IfcCurrencyEnum.PKR + + +pln = IfcCurrencyEnum.PLN + + +ptn = IfcCurrencyEnum.PTN + + +qar = IfcCurrencyEnum.QAR + + +rur = IfcCurrencyEnum.RUR + + +sar = IfcCurrencyEnum.SAR + + +scr = IfcCurrencyEnum.SCR + + +sek = IfcCurrencyEnum.SEK + + +sgd = IfcCurrencyEnum.SGD + + +skp = IfcCurrencyEnum.SKP + + +thb = IfcCurrencyEnum.THB + + +trl = IfcCurrencyEnum.TRL + + +ttd = IfcCurrencyEnum.TTD + + +twd = IfcCurrencyEnum.TWD + + +usd = IfcCurrencyEnum.USD + + +veb = IfcCurrencyEnum.VEB + + +vnd = IfcCurrencyEnum.VND + + +xeu = IfcCurrencyEnum.XEU + + +zar = IfcCurrencyEnum.ZAR + + +zwd = IfcCurrencyEnum.ZWD + + +nok = IfcCurrencyEnum.NOK + + +IfcCurtainWallTypeEnum = enum_namespace() + + +userdefined = IfcCurtainWallTypeEnum.USERDEFINED + + +notdefined = IfcCurtainWallTypeEnum.NOTDEFINED + + +IfcDamperTypeEnum = enum_namespace() + + +controldamper = IfcDamperTypeEnum.CONTROLDAMPER + + +firedamper = IfcDamperTypeEnum.FIREDAMPER + + +smokedamper = IfcDamperTypeEnum.SMOKEDAMPER + + +firesmokedamper = IfcDamperTypeEnum.FIRESMOKEDAMPER + + +backdraftdamper = IfcDamperTypeEnum.BACKDRAFTDAMPER + + +reliefdamper = IfcDamperTypeEnum.RELIEFDAMPER + + +blastdamper = IfcDamperTypeEnum.BLASTDAMPER + + +gravitydamper = IfcDamperTypeEnum.GRAVITYDAMPER + + +gravityreliefdamper = IfcDamperTypeEnum.GRAVITYRELIEFDAMPER + + +balancingdamper = IfcDamperTypeEnum.BALANCINGDAMPER + + +fumehoodexhaust = IfcDamperTypeEnum.FUMEHOODEXHAUST + + +userdefined = IfcDamperTypeEnum.USERDEFINED + + +notdefined = IfcDamperTypeEnum.NOTDEFINED + + +IfcDataOriginEnum = enum_namespace() + + +measured = IfcDataOriginEnum.MEASURED + + +predicted = IfcDataOriginEnum.PREDICTED + + +simulated = IfcDataOriginEnum.SIMULATED + + +userdefined = IfcDataOriginEnum.USERDEFINED + + +notdefined = IfcDataOriginEnum.NOTDEFINED + + +IfcDerivedUnitEnum = enum_namespace() + + +angularvelocityunit = IfcDerivedUnitEnum.ANGULARVELOCITYUNIT + + +compoundplaneangleunit = IfcDerivedUnitEnum.COMPOUNDPLANEANGLEUNIT + + +dynamicviscosityunit = IfcDerivedUnitEnum.DYNAMICVISCOSITYUNIT + + +heatfluxdensityunit = IfcDerivedUnitEnum.HEATFLUXDENSITYUNIT + + +integercountrateunit = IfcDerivedUnitEnum.INTEGERCOUNTRATEUNIT + + +isothermalmoisturecapacityunit = IfcDerivedUnitEnum.ISOTHERMALMOISTURECAPACITYUNIT + + +kinematicviscosityunit = IfcDerivedUnitEnum.KINEMATICVISCOSITYUNIT + + +linearvelocityunit = IfcDerivedUnitEnum.LINEARVELOCITYUNIT + + +massdensityunit = IfcDerivedUnitEnum.MASSDENSITYUNIT + + +massflowrateunit = IfcDerivedUnitEnum.MASSFLOWRATEUNIT + + +moisturediffusivityunit = IfcDerivedUnitEnum.MOISTUREDIFFUSIVITYUNIT + + +molecularweightunit = IfcDerivedUnitEnum.MOLECULARWEIGHTUNIT + + +specificheatcapacityunit = IfcDerivedUnitEnum.SPECIFICHEATCAPACITYUNIT + + +thermaladmittanceunit = IfcDerivedUnitEnum.THERMALADMITTANCEUNIT + + +thermalconductanceunit = IfcDerivedUnitEnum.THERMALCONDUCTANCEUNIT + + +thermalresistanceunit = IfcDerivedUnitEnum.THERMALRESISTANCEUNIT + + +thermaltransmittanceunit = IfcDerivedUnitEnum.THERMALTRANSMITTANCEUNIT + + +vaporpermeabilityunit = IfcDerivedUnitEnum.VAPORPERMEABILITYUNIT + + +volumetricflowrateunit = IfcDerivedUnitEnum.VOLUMETRICFLOWRATEUNIT + + +rotationalfrequencyunit = IfcDerivedUnitEnum.ROTATIONALFREQUENCYUNIT + + +torqueunit = IfcDerivedUnitEnum.TORQUEUNIT + + +momentofinertiaunit = IfcDerivedUnitEnum.MOMENTOFINERTIAUNIT + + +linearmomentunit = IfcDerivedUnitEnum.LINEARMOMENTUNIT + + +linearforceunit = IfcDerivedUnitEnum.LINEARFORCEUNIT + + +planarforceunit = IfcDerivedUnitEnum.PLANARFORCEUNIT + + +modulusofelasticityunit = IfcDerivedUnitEnum.MODULUSOFELASTICITYUNIT + + +shearmodulusunit = IfcDerivedUnitEnum.SHEARMODULUSUNIT + + +linearstiffnessunit = IfcDerivedUnitEnum.LINEARSTIFFNESSUNIT + + +rotationalstiffnessunit = IfcDerivedUnitEnum.ROTATIONALSTIFFNESSUNIT + + +modulusofsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFSUBGRADEREACTIONUNIT + + +accelerationunit = IfcDerivedUnitEnum.ACCELERATIONUNIT + + +curvatureunit = IfcDerivedUnitEnum.CURVATUREUNIT + + +heatingvalueunit = IfcDerivedUnitEnum.HEATINGVALUEUNIT + + +ionconcentrationunit = IfcDerivedUnitEnum.IONCONCENTRATIONUNIT + + +luminousintensitydistributionunit = IfcDerivedUnitEnum.LUMINOUSINTENSITYDISTRIBUTIONUNIT + + +massperlengthunit = IfcDerivedUnitEnum.MASSPERLENGTHUNIT + + +modulusoflinearsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFLINEARSUBGRADEREACTIONUNIT + + +modulusofrotationalsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFROTATIONALSUBGRADEREACTIONUNIT + + +phunit = IfcDerivedUnitEnum.PHUNIT + + +rotationalmassunit = IfcDerivedUnitEnum.ROTATIONALMASSUNIT + + +sectionareaintegralunit = IfcDerivedUnitEnum.SECTIONAREAINTEGRALUNIT + + +sectionmodulusunit = IfcDerivedUnitEnum.SECTIONMODULUSUNIT + + +soundpowerunit = IfcDerivedUnitEnum.SOUNDPOWERUNIT + + +soundpressureunit = IfcDerivedUnitEnum.SOUNDPRESSUREUNIT + + +temperaturegradientunit = IfcDerivedUnitEnum.TEMPERATUREGRADIENTUNIT + + +thermalexpansioncoefficientunit = IfcDerivedUnitEnum.THERMALEXPANSIONCOEFFICIENTUNIT + + +warpingconstantunit = IfcDerivedUnitEnum.WARPINGCONSTANTUNIT + + +warpingmomentunit = IfcDerivedUnitEnum.WARPINGMOMENTUNIT + + +userdefined = IfcDerivedUnitEnum.USERDEFINED + + +IfcDimensionExtentUsage = enum_namespace() + + +origin = IfcDimensionExtentUsage.ORIGIN + + +target = IfcDimensionExtentUsage.TARGET + + +IfcDirectionSenseEnum = enum_namespace() + + +positive = IfcDirectionSenseEnum.POSITIVE + + +negative = IfcDirectionSenseEnum.NEGATIVE + + +IfcDistributionChamberElementTypeEnum = enum_namespace() + + +formedduct = IfcDistributionChamberElementTypeEnum.FORMEDDUCT + + +inspectionchamber = IfcDistributionChamberElementTypeEnum.INSPECTIONCHAMBER + + +inspectionpit = IfcDistributionChamberElementTypeEnum.INSPECTIONPIT + + +manhole = IfcDistributionChamberElementTypeEnum.MANHOLE + + +meterchamber = IfcDistributionChamberElementTypeEnum.METERCHAMBER + + +sump = IfcDistributionChamberElementTypeEnum.SUMP + + +trench = IfcDistributionChamberElementTypeEnum.TRENCH + + +valvechamber = IfcDistributionChamberElementTypeEnum.VALVECHAMBER + + +userdefined = IfcDistributionChamberElementTypeEnum.USERDEFINED + + +notdefined = IfcDistributionChamberElementTypeEnum.NOTDEFINED + + +IfcDocumentConfidentialityEnum = enum_namespace() + + +public = IfcDocumentConfidentialityEnum.PUBLIC + + +restricted = IfcDocumentConfidentialityEnum.RESTRICTED + + +confidential = IfcDocumentConfidentialityEnum.CONFIDENTIAL + + +personal = IfcDocumentConfidentialityEnum.PERSONAL + + +userdefined = IfcDocumentConfidentialityEnum.USERDEFINED + + +notdefined = IfcDocumentConfidentialityEnum.NOTDEFINED + + +IfcDocumentStatusEnum = enum_namespace() + + +draft = IfcDocumentStatusEnum.DRAFT + + +finaldraft = IfcDocumentStatusEnum.FINALDRAFT + + +final = IfcDocumentStatusEnum.FINAL + + +revision = IfcDocumentStatusEnum.REVISION + + +notdefined = IfcDocumentStatusEnum.NOTDEFINED + + +IfcDoorPanelOperationEnum = enum_namespace() + + +swinging = IfcDoorPanelOperationEnum.SWINGING + + +double_acting = IfcDoorPanelOperationEnum.DOUBLE_ACTING + + +sliding = IfcDoorPanelOperationEnum.SLIDING + + +folding = IfcDoorPanelOperationEnum.FOLDING + + +revolving = IfcDoorPanelOperationEnum.REVOLVING + + +rollingup = IfcDoorPanelOperationEnum.ROLLINGUP + + +userdefined = IfcDoorPanelOperationEnum.USERDEFINED + + +notdefined = IfcDoorPanelOperationEnum.NOTDEFINED + + +IfcDoorPanelPositionEnum = enum_namespace() + + +left = IfcDoorPanelPositionEnum.LEFT + + +middle = IfcDoorPanelPositionEnum.MIDDLE + + +right = IfcDoorPanelPositionEnum.RIGHT + + +notdefined = IfcDoorPanelPositionEnum.NOTDEFINED + + +IfcDoorStyleConstructionEnum = enum_namespace() + + +aluminium = IfcDoorStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcDoorStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcDoorStyleConstructionEnum.STEEL + + +wood = IfcDoorStyleConstructionEnum.WOOD + + +aluminium_wood = IfcDoorStyleConstructionEnum.ALUMINIUM_WOOD + + +aluminium_plastic = IfcDoorStyleConstructionEnum.ALUMINIUM_PLASTIC + + +plastic = IfcDoorStyleConstructionEnum.PLASTIC + + +userdefined = IfcDoorStyleConstructionEnum.USERDEFINED + + +notdefined = IfcDoorStyleConstructionEnum.NOTDEFINED + + +IfcDoorStyleOperationEnum = enum_namespace() + + +single_swing_left = IfcDoorStyleOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorStyleOperationEnum.SINGLE_SWING_RIGHT + + +double_door_single_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_swing_left = IfcDoorStyleOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorStyleOperationEnum.DOUBLE_SWING_RIGHT + + +double_door_double_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +sliding_to_left = IfcDoorStyleOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorStyleOperationEnum.SLIDING_TO_RIGHT + + +double_door_sliding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SLIDING + + +folding_to_left = IfcDoorStyleOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorStyleOperationEnum.FOLDING_TO_RIGHT + + +double_door_folding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_FOLDING + + +revolving = IfcDoorStyleOperationEnum.REVOLVING + + +rollingup = IfcDoorStyleOperationEnum.ROLLINGUP + + +userdefined = IfcDoorStyleOperationEnum.USERDEFINED + + +notdefined = IfcDoorStyleOperationEnum.NOTDEFINED + + +IfcDuctFittingTypeEnum = enum_namespace() + + +bend = IfcDuctFittingTypeEnum.BEND + + +connector = IfcDuctFittingTypeEnum.CONNECTOR + + +entry = IfcDuctFittingTypeEnum.ENTRY + + +exit = IfcDuctFittingTypeEnum.EXIT + + +junction = IfcDuctFittingTypeEnum.JUNCTION + + +obstruction = IfcDuctFittingTypeEnum.OBSTRUCTION + + +transition = IfcDuctFittingTypeEnum.TRANSITION + + +userdefined = IfcDuctFittingTypeEnum.USERDEFINED + + +notdefined = IfcDuctFittingTypeEnum.NOTDEFINED + + +IfcDuctSegmentTypeEnum = enum_namespace() + + +rigidsegment = IfcDuctSegmentTypeEnum.RIGIDSEGMENT + + +flexiblesegment = IfcDuctSegmentTypeEnum.FLEXIBLESEGMENT + + +userdefined = IfcDuctSegmentTypeEnum.USERDEFINED + + +notdefined = IfcDuctSegmentTypeEnum.NOTDEFINED + + +IfcDuctSilencerTypeEnum = enum_namespace() + + +flatoval = IfcDuctSilencerTypeEnum.FLATOVAL + + +rectangular = IfcDuctSilencerTypeEnum.RECTANGULAR + + +round = IfcDuctSilencerTypeEnum.ROUND + + +userdefined = IfcDuctSilencerTypeEnum.USERDEFINED + + +notdefined = IfcDuctSilencerTypeEnum.NOTDEFINED + + +IfcElectricApplianceTypeEnum = enum_namespace() + + +computer = IfcElectricApplianceTypeEnum.COMPUTER + + +directwaterheater = IfcElectricApplianceTypeEnum.DIRECTWATERHEATER + + +dishwasher = IfcElectricApplianceTypeEnum.DISHWASHER + + +electriccooker = IfcElectricApplianceTypeEnum.ELECTRICCOOKER + + +electricheater = IfcElectricApplianceTypeEnum.ELECTRICHEATER + + +facsimile = IfcElectricApplianceTypeEnum.FACSIMILE + + +freestandingfan = IfcElectricApplianceTypeEnum.FREESTANDINGFAN + + +freezer = IfcElectricApplianceTypeEnum.FREEZER + + +fridge_freezer = IfcElectricApplianceTypeEnum.FRIDGE_FREEZER + + +handdryer = IfcElectricApplianceTypeEnum.HANDDRYER + + +indirectwaterheater = IfcElectricApplianceTypeEnum.INDIRECTWATERHEATER + + +microwave = IfcElectricApplianceTypeEnum.MICROWAVE + + +photocopier = IfcElectricApplianceTypeEnum.PHOTOCOPIER + + +printer = IfcElectricApplianceTypeEnum.PRINTER + + +refrigerator = IfcElectricApplianceTypeEnum.REFRIGERATOR + + +radiantheater = IfcElectricApplianceTypeEnum.RADIANTHEATER + + +scanner = IfcElectricApplianceTypeEnum.SCANNER + + +telephone = IfcElectricApplianceTypeEnum.TELEPHONE + + +tumbledryer = IfcElectricApplianceTypeEnum.TUMBLEDRYER + + +tv = IfcElectricApplianceTypeEnum.TV + + +vendingmachine = IfcElectricApplianceTypeEnum.VENDINGMACHINE + + +washingmachine = IfcElectricApplianceTypeEnum.WASHINGMACHINE + + +waterheater = IfcElectricApplianceTypeEnum.WATERHEATER + + +watercooler = IfcElectricApplianceTypeEnum.WATERCOOLER + + +userdefined = IfcElectricApplianceTypeEnum.USERDEFINED + + +notdefined = IfcElectricApplianceTypeEnum.NOTDEFINED + + +IfcElectricCurrentEnum = enum_namespace() + + +alternating = IfcElectricCurrentEnum.ALTERNATING + + +direct = IfcElectricCurrentEnum.DIRECT + + +notdefined = IfcElectricCurrentEnum.NOTDEFINED + + +IfcElectricDistributionPointFunctionEnum = enum_namespace() + + +alarmpanel = IfcElectricDistributionPointFunctionEnum.ALARMPANEL + + +consumerunit = IfcElectricDistributionPointFunctionEnum.CONSUMERUNIT + + +controlpanel = IfcElectricDistributionPointFunctionEnum.CONTROLPANEL + + +distributionboard = IfcElectricDistributionPointFunctionEnum.DISTRIBUTIONBOARD + + +gasdetectorpanel = IfcElectricDistributionPointFunctionEnum.GASDETECTORPANEL + + +indicatorpanel = IfcElectricDistributionPointFunctionEnum.INDICATORPANEL + + +mimicpanel = IfcElectricDistributionPointFunctionEnum.MIMICPANEL + + +motorcontrolcentre = IfcElectricDistributionPointFunctionEnum.MOTORCONTROLCENTRE + + +switchboard = IfcElectricDistributionPointFunctionEnum.SWITCHBOARD + + +userdefined = IfcElectricDistributionPointFunctionEnum.USERDEFINED + + +notdefined = IfcElectricDistributionPointFunctionEnum.NOTDEFINED + + +IfcElectricFlowStorageDeviceTypeEnum = enum_namespace() + + +battery = IfcElectricFlowStorageDeviceTypeEnum.BATTERY + + +capacitorbank = IfcElectricFlowStorageDeviceTypeEnum.CAPACITORBANK + + +harmonicfilter = IfcElectricFlowStorageDeviceTypeEnum.HARMONICFILTER + + +inductorbank = IfcElectricFlowStorageDeviceTypeEnum.INDUCTORBANK + + +ups = IfcElectricFlowStorageDeviceTypeEnum.UPS + + +userdefined = IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowStorageDeviceTypeEnum.NOTDEFINED + + +IfcElectricGeneratorTypeEnum = enum_namespace() + + +userdefined = IfcElectricGeneratorTypeEnum.USERDEFINED + + +notdefined = IfcElectricGeneratorTypeEnum.NOTDEFINED + + +IfcElectricHeaterTypeEnum = enum_namespace() + + +electricpointheater = IfcElectricHeaterTypeEnum.ELECTRICPOINTHEATER + + +electriccableheater = IfcElectricHeaterTypeEnum.ELECTRICCABLEHEATER + + +electricmatheater = IfcElectricHeaterTypeEnum.ELECTRICMATHEATER + + +userdefined = IfcElectricHeaterTypeEnum.USERDEFINED + + +notdefined = IfcElectricHeaterTypeEnum.NOTDEFINED + + +IfcElectricMotorTypeEnum = enum_namespace() + + +dc = IfcElectricMotorTypeEnum.DC + + +induction = IfcElectricMotorTypeEnum.INDUCTION + + +polyphase = IfcElectricMotorTypeEnum.POLYPHASE + + +reluctancesynchronous = IfcElectricMotorTypeEnum.RELUCTANCESYNCHRONOUS + + +synchronous = IfcElectricMotorTypeEnum.SYNCHRONOUS + + +userdefined = IfcElectricMotorTypeEnum.USERDEFINED + + +notdefined = IfcElectricMotorTypeEnum.NOTDEFINED + + +IfcElectricTimeControlTypeEnum = enum_namespace() + + +timeclock = IfcElectricTimeControlTypeEnum.TIMECLOCK + + +timedelay = IfcElectricTimeControlTypeEnum.TIMEDELAY + + +relay = IfcElectricTimeControlTypeEnum.RELAY + + +userdefined = IfcElectricTimeControlTypeEnum.USERDEFINED + + +notdefined = IfcElectricTimeControlTypeEnum.NOTDEFINED + + +IfcElementAssemblyTypeEnum = enum_namespace() + + +accessory_assembly = IfcElementAssemblyTypeEnum.ACCESSORY_ASSEMBLY + + +arch = IfcElementAssemblyTypeEnum.ARCH + + +beam_grid = IfcElementAssemblyTypeEnum.BEAM_GRID + + +braced_frame = IfcElementAssemblyTypeEnum.BRACED_FRAME + + +girder = IfcElementAssemblyTypeEnum.GIRDER + + +reinforcement_unit = IfcElementAssemblyTypeEnum.REINFORCEMENT_UNIT + + +rigid_frame = IfcElementAssemblyTypeEnum.RIGID_FRAME + + +slab_field = IfcElementAssemblyTypeEnum.SLAB_FIELD + + +truss = IfcElementAssemblyTypeEnum.TRUSS + + +userdefined = IfcElementAssemblyTypeEnum.USERDEFINED + + +notdefined = IfcElementAssemblyTypeEnum.NOTDEFINED + + +IfcElementCompositionEnum = enum_namespace() + + +complex = IfcElementCompositionEnum.COMPLEX + + +element = IfcElementCompositionEnum.ELEMENT + + +partial = IfcElementCompositionEnum.PARTIAL + + +IfcEnergySequenceEnum = enum_namespace() + + +primary = IfcEnergySequenceEnum.PRIMARY + + +secondary = IfcEnergySequenceEnum.SECONDARY + + +tertiary = IfcEnergySequenceEnum.TERTIARY + + +auxiliary = IfcEnergySequenceEnum.AUXILIARY + + +userdefined = IfcEnergySequenceEnum.USERDEFINED + + +notdefined = IfcEnergySequenceEnum.NOTDEFINED + + +IfcEnvironmentalImpactCategoryEnum = enum_namespace() + + +combinedvalue = IfcEnvironmentalImpactCategoryEnum.COMBINEDVALUE + + +disposal = IfcEnvironmentalImpactCategoryEnum.DISPOSAL + + +extraction = IfcEnvironmentalImpactCategoryEnum.EXTRACTION + + +installation = IfcEnvironmentalImpactCategoryEnum.INSTALLATION + + +manufacture = IfcEnvironmentalImpactCategoryEnum.MANUFACTURE + + +transportation = IfcEnvironmentalImpactCategoryEnum.TRANSPORTATION + + +userdefined = IfcEnvironmentalImpactCategoryEnum.USERDEFINED + + +notdefined = IfcEnvironmentalImpactCategoryEnum.NOTDEFINED + + +IfcEvaporativeCoolerTypeEnum = enum_namespace() + + +directevaporativerandommediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER + + +directevaporativerigidmediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER + + +directevaporativeslingerspackagedaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER + + +directevaporativepackagedrotaryaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER + + +directevaporativeairwasher = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEAIRWASHER + + +indirectevaporativepackageaircooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEPACKAGEAIRCOOLER + + +indirectevaporativewetcoil = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEWETCOIL + + +indirectevaporativecoolingtowerorcoilcooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER + + +indirectdirectcombination = IfcEvaporativeCoolerTypeEnum.INDIRECTDIRECTCOMBINATION + + +userdefined = IfcEvaporativeCoolerTypeEnum.USERDEFINED + + +notdefined = IfcEvaporativeCoolerTypeEnum.NOTDEFINED + + +IfcEvaporatorTypeEnum = enum_namespace() + + +directexpansionshellandtube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONSHELLANDTUBE + + +directexpansiontubeintube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONTUBEINTUBE + + +directexpansionbrazedplate = IfcEvaporatorTypeEnum.DIRECTEXPANSIONBRAZEDPLATE + + +floodedshellandtube = IfcEvaporatorTypeEnum.FLOODEDSHELLANDTUBE + + +shellandcoil = IfcEvaporatorTypeEnum.SHELLANDCOIL + + +userdefined = IfcEvaporatorTypeEnum.USERDEFINED + + +notdefined = IfcEvaporatorTypeEnum.NOTDEFINED + + +IfcFanTypeEnum = enum_namespace() + + +centrifugalforwardcurved = IfcFanTypeEnum.CENTRIFUGALFORWARDCURVED + + +centrifugalradial = IfcFanTypeEnum.CENTRIFUGALRADIAL + + +centrifugalbackwardinclinedcurved = IfcFanTypeEnum.CENTRIFUGALBACKWARDINCLINEDCURVED + + +centrifugalairfoil = IfcFanTypeEnum.CENTRIFUGALAIRFOIL + + +tubeaxial = IfcFanTypeEnum.TUBEAXIAL + + +vaneaxial = IfcFanTypeEnum.VANEAXIAL + + +propelloraxial = IfcFanTypeEnum.PROPELLORAXIAL + + +userdefined = IfcFanTypeEnum.USERDEFINED + + +notdefined = IfcFanTypeEnum.NOTDEFINED + + +IfcFilterTypeEnum = enum_namespace() + + +airparticlefilter = IfcFilterTypeEnum.AIRPARTICLEFILTER + + +odorfilter = IfcFilterTypeEnum.ODORFILTER + + +oilfilter = IfcFilterTypeEnum.OILFILTER + + +strainer = IfcFilterTypeEnum.STRAINER + + +waterfilter = IfcFilterTypeEnum.WATERFILTER + + +userdefined = IfcFilterTypeEnum.USERDEFINED + + +notdefined = IfcFilterTypeEnum.NOTDEFINED + + +IfcFireSuppressionTerminalTypeEnum = enum_namespace() + + +breechinginlet = IfcFireSuppressionTerminalTypeEnum.BREECHINGINLET + + +firehydrant = IfcFireSuppressionTerminalTypeEnum.FIREHYDRANT + + +hosereel = IfcFireSuppressionTerminalTypeEnum.HOSEREEL + + +sprinkler = IfcFireSuppressionTerminalTypeEnum.SPRINKLER + + +sprinklerdeflector = IfcFireSuppressionTerminalTypeEnum.SPRINKLERDEFLECTOR + + +userdefined = IfcFireSuppressionTerminalTypeEnum.USERDEFINED + + +notdefined = IfcFireSuppressionTerminalTypeEnum.NOTDEFINED + + +IfcFlowDirectionEnum = enum_namespace() + + +source = IfcFlowDirectionEnum.SOURCE + + +sink = IfcFlowDirectionEnum.SINK + + +sourceandsink = IfcFlowDirectionEnum.SOURCEANDSINK + + +notdefined = IfcFlowDirectionEnum.NOTDEFINED + + +IfcFlowInstrumentTypeEnum = enum_namespace() + + +pressuregauge = IfcFlowInstrumentTypeEnum.PRESSUREGAUGE + + +thermometer = IfcFlowInstrumentTypeEnum.THERMOMETER + + +ammeter = IfcFlowInstrumentTypeEnum.AMMETER + + +frequencymeter = IfcFlowInstrumentTypeEnum.FREQUENCYMETER + + +powerfactormeter = IfcFlowInstrumentTypeEnum.POWERFACTORMETER + + +phaseanglemeter = IfcFlowInstrumentTypeEnum.PHASEANGLEMETER + + +voltmeter_peak = IfcFlowInstrumentTypeEnum.VOLTMETER_PEAK + + +voltmeter_rms = IfcFlowInstrumentTypeEnum.VOLTMETER_RMS + + +userdefined = IfcFlowInstrumentTypeEnum.USERDEFINED + + +notdefined = IfcFlowInstrumentTypeEnum.NOTDEFINED + + +IfcFlowMeterTypeEnum = enum_namespace() + + +electricmeter = IfcFlowMeterTypeEnum.ELECTRICMETER + + +energymeter = IfcFlowMeterTypeEnum.ENERGYMETER + + +flowmeter = IfcFlowMeterTypeEnum.FLOWMETER + + +gasmeter = IfcFlowMeterTypeEnum.GASMETER + + +oilmeter = IfcFlowMeterTypeEnum.OILMETER + + +watermeter = IfcFlowMeterTypeEnum.WATERMETER + + +userdefined = IfcFlowMeterTypeEnum.USERDEFINED + + +notdefined = IfcFlowMeterTypeEnum.NOTDEFINED + + +IfcFootingTypeEnum = enum_namespace() + + +footing_beam = IfcFootingTypeEnum.FOOTING_BEAM + + +pad_footing = IfcFootingTypeEnum.PAD_FOOTING + + +pile_cap = IfcFootingTypeEnum.PILE_CAP + + +strip_footing = IfcFootingTypeEnum.STRIP_FOOTING + + +userdefined = IfcFootingTypeEnum.USERDEFINED + + +notdefined = IfcFootingTypeEnum.NOTDEFINED + + +IfcGasTerminalTypeEnum = enum_namespace() + + +gasappliance = IfcGasTerminalTypeEnum.GASAPPLIANCE + + +gasbooster = IfcGasTerminalTypeEnum.GASBOOSTER + + +gasburner = IfcGasTerminalTypeEnum.GASBURNER + + +userdefined = IfcGasTerminalTypeEnum.USERDEFINED + + +notdefined = IfcGasTerminalTypeEnum.NOTDEFINED + + +IfcGeometricProjectionEnum = enum_namespace() + + +graph_view = IfcGeometricProjectionEnum.GRAPH_VIEW + + +sketch_view = IfcGeometricProjectionEnum.SKETCH_VIEW + + +model_view = IfcGeometricProjectionEnum.MODEL_VIEW + + +plan_view = IfcGeometricProjectionEnum.PLAN_VIEW + + +reflected_plan_view = IfcGeometricProjectionEnum.REFLECTED_PLAN_VIEW + + +section_view = IfcGeometricProjectionEnum.SECTION_VIEW + + +elevation_view = IfcGeometricProjectionEnum.ELEVATION_VIEW + + +userdefined = IfcGeometricProjectionEnum.USERDEFINED + + +notdefined = IfcGeometricProjectionEnum.NOTDEFINED + + +IfcGlobalOrLocalEnum = enum_namespace() + + +global_coords = IfcGlobalOrLocalEnum.GLOBAL_COORDS + + +local_coords = IfcGlobalOrLocalEnum.LOCAL_COORDS + + +IfcHeatExchangerTypeEnum = enum_namespace() + + +plate = IfcHeatExchangerTypeEnum.PLATE + + +shellandtube = IfcHeatExchangerTypeEnum.SHELLANDTUBE + + +userdefined = IfcHeatExchangerTypeEnum.USERDEFINED + + +notdefined = IfcHeatExchangerTypeEnum.NOTDEFINED + + +IfcHumidifierTypeEnum = enum_namespace() + + +steaminjection = IfcHumidifierTypeEnum.STEAMINJECTION + + +adiabaticairwasher = IfcHumidifierTypeEnum.ADIABATICAIRWASHER + + +adiabaticpan = IfcHumidifierTypeEnum.ADIABATICPAN + + +adiabaticwettedelement = IfcHumidifierTypeEnum.ADIABATICWETTEDELEMENT + + +adiabaticatomizing = IfcHumidifierTypeEnum.ADIABATICATOMIZING + + +adiabaticultrasonic = IfcHumidifierTypeEnum.ADIABATICULTRASONIC + + +adiabaticrigidmedia = IfcHumidifierTypeEnum.ADIABATICRIGIDMEDIA + + +adiabaticcompressedairnozzle = IfcHumidifierTypeEnum.ADIABATICCOMPRESSEDAIRNOZZLE + + +assistedelectric = IfcHumidifierTypeEnum.ASSISTEDELECTRIC + + +assistednaturalgas = IfcHumidifierTypeEnum.ASSISTEDNATURALGAS + + +assistedpropane = IfcHumidifierTypeEnum.ASSISTEDPROPANE + + +assistedbutane = IfcHumidifierTypeEnum.ASSISTEDBUTANE + + +assistedsteam = IfcHumidifierTypeEnum.ASSISTEDSTEAM + + +userdefined = IfcHumidifierTypeEnum.USERDEFINED + + +notdefined = IfcHumidifierTypeEnum.NOTDEFINED + + +IfcInternalOrExternalEnum = enum_namespace() + + +internal = IfcInternalOrExternalEnum.INTERNAL + + +external = IfcInternalOrExternalEnum.EXTERNAL + + +notdefined = IfcInternalOrExternalEnum.NOTDEFINED + + +IfcInventoryTypeEnum = enum_namespace() + + +assetinventory = IfcInventoryTypeEnum.ASSETINVENTORY + + +spaceinventory = IfcInventoryTypeEnum.SPACEINVENTORY + + +furnitureinventory = IfcInventoryTypeEnum.FURNITUREINVENTORY + + +userdefined = IfcInventoryTypeEnum.USERDEFINED + + +notdefined = IfcInventoryTypeEnum.NOTDEFINED + + +IfcJunctionBoxTypeEnum = enum_namespace() + + +userdefined = IfcJunctionBoxTypeEnum.USERDEFINED + + +notdefined = IfcJunctionBoxTypeEnum.NOTDEFINED + + +IfcLampTypeEnum = enum_namespace() + + +compactfluorescent = IfcLampTypeEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLampTypeEnum.FLUORESCENT + + +highpressuremercury = IfcLampTypeEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLampTypeEnum.HIGHPRESSURESODIUM + + +metalhalide = IfcLampTypeEnum.METALHALIDE + + +tungstenfilament = IfcLampTypeEnum.TUNGSTENFILAMENT + + +userdefined = IfcLampTypeEnum.USERDEFINED + + +notdefined = IfcLampTypeEnum.NOTDEFINED + + +IfcLayerSetDirectionEnum = enum_namespace() + + +axis1 = IfcLayerSetDirectionEnum.AXIS1 + + +axis2 = IfcLayerSetDirectionEnum.AXIS2 + + +axis3 = IfcLayerSetDirectionEnum.AXIS3 + + +IfcLightDistributionCurveEnum = enum_namespace() + + +type_a = IfcLightDistributionCurveEnum.TYPE_A + + +type_b = IfcLightDistributionCurveEnum.TYPE_B + + +type_c = IfcLightDistributionCurveEnum.TYPE_C + + +notdefined = IfcLightDistributionCurveEnum.NOTDEFINED + + +IfcLightEmissionSourceEnum = enum_namespace() + + +compactfluorescent = IfcLightEmissionSourceEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLightEmissionSourceEnum.FLUORESCENT + + +highpressuremercury = IfcLightEmissionSourceEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLightEmissionSourceEnum.HIGHPRESSURESODIUM + + +lightemittingdiode = IfcLightEmissionSourceEnum.LIGHTEMITTINGDIODE + + +lowpressuresodium = IfcLightEmissionSourceEnum.LOWPRESSURESODIUM + + +lowvoltagehalogen = IfcLightEmissionSourceEnum.LOWVOLTAGEHALOGEN + + +mainvoltagehalogen = IfcLightEmissionSourceEnum.MAINVOLTAGEHALOGEN + + +metalhalide = IfcLightEmissionSourceEnum.METALHALIDE + + +tungstenfilament = IfcLightEmissionSourceEnum.TUNGSTENFILAMENT + + +notdefined = IfcLightEmissionSourceEnum.NOTDEFINED + + +IfcLightFixtureTypeEnum = enum_namespace() + + +pointsource = IfcLightFixtureTypeEnum.POINTSOURCE + + +directionsource = IfcLightFixtureTypeEnum.DIRECTIONSOURCE + + +userdefined = IfcLightFixtureTypeEnum.USERDEFINED + + +notdefined = IfcLightFixtureTypeEnum.NOTDEFINED + + +IfcLoadGroupTypeEnum = enum_namespace() + + +load_group = IfcLoadGroupTypeEnum.LOAD_GROUP + + +load_case = IfcLoadGroupTypeEnum.LOAD_CASE + + +load_combination_group = IfcLoadGroupTypeEnum.LOAD_COMBINATION_GROUP + + +load_combination = IfcLoadGroupTypeEnum.LOAD_COMBINATION + + +userdefined = IfcLoadGroupTypeEnum.USERDEFINED + + +notdefined = IfcLoadGroupTypeEnum.NOTDEFINED + + +IfcLogicalOperatorEnum = enum_namespace() + + +logicaland = IfcLogicalOperatorEnum.LOGICALAND + + +logicalor = IfcLogicalOperatorEnum.LOGICALOR + + +IfcMemberTypeEnum = enum_namespace() + + +brace = IfcMemberTypeEnum.BRACE + + +chord = IfcMemberTypeEnum.CHORD + + +collar = IfcMemberTypeEnum.COLLAR + + +member = IfcMemberTypeEnum.MEMBER + + +mullion = IfcMemberTypeEnum.MULLION + + +plate = IfcMemberTypeEnum.PLATE + + +post = IfcMemberTypeEnum.POST + + +purlin = IfcMemberTypeEnum.PURLIN + + +rafter = IfcMemberTypeEnum.RAFTER + + +stringer = IfcMemberTypeEnum.STRINGER + + +strut = IfcMemberTypeEnum.STRUT + + +stud = IfcMemberTypeEnum.STUD + + +userdefined = IfcMemberTypeEnum.USERDEFINED + + +notdefined = IfcMemberTypeEnum.NOTDEFINED + + +IfcMotorConnectionTypeEnum = enum_namespace() + + +beltdrive = IfcMotorConnectionTypeEnum.BELTDRIVE + + +coupling = IfcMotorConnectionTypeEnum.COUPLING + + +directdrive = IfcMotorConnectionTypeEnum.DIRECTDRIVE + + +userdefined = IfcMotorConnectionTypeEnum.USERDEFINED + + +notdefined = IfcMotorConnectionTypeEnum.NOTDEFINED + + +IfcNullStyle = enum_namespace() + + +null = IfcNullStyle.NULL + + +IfcObjectTypeEnum = enum_namespace() + + +product = IfcObjectTypeEnum.PRODUCT + + +process = IfcObjectTypeEnum.PROCESS + + +control = IfcObjectTypeEnum.CONTROL + + +resource = IfcObjectTypeEnum.RESOURCE + + +actor = IfcObjectTypeEnum.ACTOR + + +group = IfcObjectTypeEnum.GROUP + + +project = IfcObjectTypeEnum.PROJECT + + +notdefined = IfcObjectTypeEnum.NOTDEFINED + + +IfcObjectiveEnum = enum_namespace() + + +codecompliance = IfcObjectiveEnum.CODECOMPLIANCE + + +designintent = IfcObjectiveEnum.DESIGNINTENT + + +healthandsafety = IfcObjectiveEnum.HEALTHANDSAFETY + + +requirement = IfcObjectiveEnum.REQUIREMENT + + +specification = IfcObjectiveEnum.SPECIFICATION + + +triggercondition = IfcObjectiveEnum.TRIGGERCONDITION + + +userdefined = IfcObjectiveEnum.USERDEFINED + + +notdefined = IfcObjectiveEnum.NOTDEFINED + + +IfcOccupantTypeEnum = enum_namespace() + + +assignee = IfcOccupantTypeEnum.ASSIGNEE + + +assignor = IfcOccupantTypeEnum.ASSIGNOR + + +lessee = IfcOccupantTypeEnum.LESSEE + + +lessor = IfcOccupantTypeEnum.LESSOR + + +lettingagent = IfcOccupantTypeEnum.LETTINGAGENT + + +owner = IfcOccupantTypeEnum.OWNER + + +tenant = IfcOccupantTypeEnum.TENANT + + +userdefined = IfcOccupantTypeEnum.USERDEFINED + + +notdefined = IfcOccupantTypeEnum.NOTDEFINED + + +IfcOutletTypeEnum = enum_namespace() + + +audiovisualoutlet = IfcOutletTypeEnum.AUDIOVISUALOUTLET + + +communicationsoutlet = IfcOutletTypeEnum.COMMUNICATIONSOUTLET + + +poweroutlet = IfcOutletTypeEnum.POWEROUTLET + + +userdefined = IfcOutletTypeEnum.USERDEFINED + + +notdefined = IfcOutletTypeEnum.NOTDEFINED + + +IfcPermeableCoveringOperationEnum = enum_namespace() + + +grill = IfcPermeableCoveringOperationEnum.GRILL + + +louver = IfcPermeableCoveringOperationEnum.LOUVER + + +screen = IfcPermeableCoveringOperationEnum.SCREEN + + +userdefined = IfcPermeableCoveringOperationEnum.USERDEFINED + + +notdefined = IfcPermeableCoveringOperationEnum.NOTDEFINED + + +IfcPhysicalOrVirtualEnum = enum_namespace() + + +physical = IfcPhysicalOrVirtualEnum.PHYSICAL + + +virtual = IfcPhysicalOrVirtualEnum.VIRTUAL + + +notdefined = IfcPhysicalOrVirtualEnum.NOTDEFINED + + +IfcPileConstructionEnum = enum_namespace() + + +cast_in_place = IfcPileConstructionEnum.CAST_IN_PLACE + + +composite = IfcPileConstructionEnum.COMPOSITE + + +precast_concrete = IfcPileConstructionEnum.PRECAST_CONCRETE + + +prefab_steel = IfcPileConstructionEnum.PREFAB_STEEL + + +userdefined = IfcPileConstructionEnum.USERDEFINED + + +notdefined = IfcPileConstructionEnum.NOTDEFINED + + +IfcPileTypeEnum = enum_namespace() + + +cohesion = IfcPileTypeEnum.COHESION + + +friction = IfcPileTypeEnum.FRICTION + + +support = IfcPileTypeEnum.SUPPORT + + +userdefined = IfcPileTypeEnum.USERDEFINED + + +notdefined = IfcPileTypeEnum.NOTDEFINED + + +IfcPipeFittingTypeEnum = enum_namespace() + + +bend = IfcPipeFittingTypeEnum.BEND + + +connector = IfcPipeFittingTypeEnum.CONNECTOR + + +entry = IfcPipeFittingTypeEnum.ENTRY + + +exit = IfcPipeFittingTypeEnum.EXIT + + +junction = IfcPipeFittingTypeEnum.JUNCTION + + +obstruction = IfcPipeFittingTypeEnum.OBSTRUCTION + + +transition = IfcPipeFittingTypeEnum.TRANSITION + + +userdefined = IfcPipeFittingTypeEnum.USERDEFINED + + +notdefined = IfcPipeFittingTypeEnum.NOTDEFINED + + +IfcPipeSegmentTypeEnum = enum_namespace() + + +flexiblesegment = IfcPipeSegmentTypeEnum.FLEXIBLESEGMENT + + +rigidsegment = IfcPipeSegmentTypeEnum.RIGIDSEGMENT + + +gutter = IfcPipeSegmentTypeEnum.GUTTER + + +spool = IfcPipeSegmentTypeEnum.SPOOL + + +userdefined = IfcPipeSegmentTypeEnum.USERDEFINED + + +notdefined = IfcPipeSegmentTypeEnum.NOTDEFINED + + +IfcPlateTypeEnum = enum_namespace() + + +curtain_panel = IfcPlateTypeEnum.CURTAIN_PANEL + + +sheet = IfcPlateTypeEnum.SHEET + + +userdefined = IfcPlateTypeEnum.USERDEFINED + + +notdefined = IfcPlateTypeEnum.NOTDEFINED + + +IfcProcedureTypeEnum = enum_namespace() + + +advice_caution = IfcProcedureTypeEnum.ADVICE_CAUTION + + +advice_note = IfcProcedureTypeEnum.ADVICE_NOTE + + +advice_warning = IfcProcedureTypeEnum.ADVICE_WARNING + + +calibration = IfcProcedureTypeEnum.CALIBRATION + + +diagnostic = IfcProcedureTypeEnum.DIAGNOSTIC + + +shutdown = IfcProcedureTypeEnum.SHUTDOWN + + +startup = IfcProcedureTypeEnum.STARTUP + + +userdefined = IfcProcedureTypeEnum.USERDEFINED + + +notdefined = IfcProcedureTypeEnum.NOTDEFINED + + +IfcProfileTypeEnum = enum_namespace() + + +curve = IfcProfileTypeEnum.CURVE + + +area = IfcProfileTypeEnum.AREA + + +IfcProjectOrderRecordTypeEnum = enum_namespace() + + +change = IfcProjectOrderRecordTypeEnum.CHANGE + + +maintenance = IfcProjectOrderRecordTypeEnum.MAINTENANCE + + +move = IfcProjectOrderRecordTypeEnum.MOVE + + +purchase = IfcProjectOrderRecordTypeEnum.PURCHASE + + +work = IfcProjectOrderRecordTypeEnum.WORK + + +userdefined = IfcProjectOrderRecordTypeEnum.USERDEFINED + + +notdefined = IfcProjectOrderRecordTypeEnum.NOTDEFINED + + +IfcProjectOrderTypeEnum = enum_namespace() + + +changeorder = IfcProjectOrderTypeEnum.CHANGEORDER + + +maintenanceworkorder = IfcProjectOrderTypeEnum.MAINTENANCEWORKORDER + + +moveorder = IfcProjectOrderTypeEnum.MOVEORDER + + +purchaseorder = IfcProjectOrderTypeEnum.PURCHASEORDER + + +workorder = IfcProjectOrderTypeEnum.WORKORDER + + +userdefined = IfcProjectOrderTypeEnum.USERDEFINED + + +notdefined = IfcProjectOrderTypeEnum.NOTDEFINED + + +IfcProjectedOrTrueLengthEnum = enum_namespace() + + +projected_length = IfcProjectedOrTrueLengthEnum.PROJECTED_LENGTH + + +true_length = IfcProjectedOrTrueLengthEnum.TRUE_LENGTH + + +IfcPropertySourceEnum = enum_namespace() + + +design = IfcPropertySourceEnum.DESIGN + + +designmaximum = IfcPropertySourceEnum.DESIGNMAXIMUM + + +designminimum = IfcPropertySourceEnum.DESIGNMINIMUM + + +simulated = IfcPropertySourceEnum.SIMULATED + + +asbuilt = IfcPropertySourceEnum.ASBUILT + + +commissioning = IfcPropertySourceEnum.COMMISSIONING + + +measured = IfcPropertySourceEnum.MEASURED + + +userdefined = IfcPropertySourceEnum.USERDEFINED + + +notknown = IfcPropertySourceEnum.NOTKNOWN + + +IfcProtectiveDeviceTypeEnum = enum_namespace() + + +fusedisconnector = IfcProtectiveDeviceTypeEnum.FUSEDISCONNECTOR + + +circuitbreaker = IfcProtectiveDeviceTypeEnum.CIRCUITBREAKER + + +earthfailuredevice = IfcProtectiveDeviceTypeEnum.EARTHFAILUREDEVICE + + +residualcurrentcircuitbreaker = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTCIRCUITBREAKER + + +residualcurrentswitch = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTSWITCH + + +varistor = IfcProtectiveDeviceTypeEnum.VARISTOR + + +userdefined = IfcProtectiveDeviceTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTypeEnum.NOTDEFINED + + +IfcPumpTypeEnum = enum_namespace() + + +circulator = IfcPumpTypeEnum.CIRCULATOR + + +endsuction = IfcPumpTypeEnum.ENDSUCTION + + +splitcase = IfcPumpTypeEnum.SPLITCASE + + +verticalinline = IfcPumpTypeEnum.VERTICALINLINE + + +verticalturbine = IfcPumpTypeEnum.VERTICALTURBINE + + +userdefined = IfcPumpTypeEnum.USERDEFINED + + +notdefined = IfcPumpTypeEnum.NOTDEFINED + + +IfcRailingTypeEnum = enum_namespace() + + +handrail = IfcRailingTypeEnum.HANDRAIL + + +guardrail = IfcRailingTypeEnum.GUARDRAIL + + +balustrade = IfcRailingTypeEnum.BALUSTRADE + + +userdefined = IfcRailingTypeEnum.USERDEFINED + + +notdefined = IfcRailingTypeEnum.NOTDEFINED + + +IfcRampFlightTypeEnum = enum_namespace() + + +straight = IfcRampFlightTypeEnum.STRAIGHT + + +spiral = IfcRampFlightTypeEnum.SPIRAL + + +userdefined = IfcRampFlightTypeEnum.USERDEFINED + + +notdefined = IfcRampFlightTypeEnum.NOTDEFINED + + +IfcRampTypeEnum = enum_namespace() + + +straight_run_ramp = IfcRampTypeEnum.STRAIGHT_RUN_RAMP + + +two_straight_run_ramp = IfcRampTypeEnum.TWO_STRAIGHT_RUN_RAMP + + +quarter_turn_ramp = IfcRampTypeEnum.QUARTER_TURN_RAMP + + +two_quarter_turn_ramp = IfcRampTypeEnum.TWO_QUARTER_TURN_RAMP + + +half_turn_ramp = IfcRampTypeEnum.HALF_TURN_RAMP + + +spiral_ramp = IfcRampTypeEnum.SPIRAL_RAMP + + +userdefined = IfcRampTypeEnum.USERDEFINED + + +notdefined = IfcRampTypeEnum.NOTDEFINED + + +IfcReflectanceMethodEnum = enum_namespace() + + +blinn = IfcReflectanceMethodEnum.BLINN + + +flat = IfcReflectanceMethodEnum.FLAT + + +glass = IfcReflectanceMethodEnum.GLASS + + +matt = IfcReflectanceMethodEnum.MATT + + +metal = IfcReflectanceMethodEnum.METAL + + +mirror = IfcReflectanceMethodEnum.MIRROR + + +phong = IfcReflectanceMethodEnum.PHONG + + +plastic = IfcReflectanceMethodEnum.PLASTIC + + +strauss = IfcReflectanceMethodEnum.STRAUSS + + +notdefined = IfcReflectanceMethodEnum.NOTDEFINED + + +IfcReinforcingBarRoleEnum = enum_namespace() + + +main = IfcReinforcingBarRoleEnum.MAIN + + +shear = IfcReinforcingBarRoleEnum.SHEAR + + +ligature = IfcReinforcingBarRoleEnum.LIGATURE + + +stud = IfcReinforcingBarRoleEnum.STUD + + +punching = IfcReinforcingBarRoleEnum.PUNCHING + + +edge = IfcReinforcingBarRoleEnum.EDGE + + +ring = IfcReinforcingBarRoleEnum.RING + + +userdefined = IfcReinforcingBarRoleEnum.USERDEFINED + + +notdefined = IfcReinforcingBarRoleEnum.NOTDEFINED + + +IfcReinforcingBarSurfaceEnum = enum_namespace() + + +plain = IfcReinforcingBarSurfaceEnum.PLAIN + + +textured = IfcReinforcingBarSurfaceEnum.TEXTURED + + +IfcResourceConsumptionEnum = enum_namespace() + + +consumed = IfcResourceConsumptionEnum.CONSUMED + + +partiallyconsumed = IfcResourceConsumptionEnum.PARTIALLYCONSUMED + + +notconsumed = IfcResourceConsumptionEnum.NOTCONSUMED + + +occupied = IfcResourceConsumptionEnum.OCCUPIED + + +partiallyoccupied = IfcResourceConsumptionEnum.PARTIALLYOCCUPIED + + +notoccupied = IfcResourceConsumptionEnum.NOTOCCUPIED + + +userdefined = IfcResourceConsumptionEnum.USERDEFINED + + +notdefined = IfcResourceConsumptionEnum.NOTDEFINED + + +IfcRibPlateDirectionEnum = enum_namespace() + + +direction_x = IfcRibPlateDirectionEnum.DIRECTION_X + + +direction_y = IfcRibPlateDirectionEnum.DIRECTION_Y + + +IfcRoleEnum = enum_namespace() + + +supplier = IfcRoleEnum.SUPPLIER + + +manufacturer = IfcRoleEnum.MANUFACTURER + + +contractor = IfcRoleEnum.CONTRACTOR + + +subcontractor = IfcRoleEnum.SUBCONTRACTOR + + +architect = IfcRoleEnum.ARCHITECT + + +structuralengineer = IfcRoleEnum.STRUCTURALENGINEER + + +costengineer = IfcRoleEnum.COSTENGINEER + + +client = IfcRoleEnum.CLIENT + + +buildingowner = IfcRoleEnum.BUILDINGOWNER + + +buildingoperator = IfcRoleEnum.BUILDINGOPERATOR + + +mechanicalengineer = IfcRoleEnum.MECHANICALENGINEER + + +electricalengineer = IfcRoleEnum.ELECTRICALENGINEER + + +projectmanager = IfcRoleEnum.PROJECTMANAGER + + +facilitiesmanager = IfcRoleEnum.FACILITIESMANAGER + + +civilengineer = IfcRoleEnum.CIVILENGINEER + + +comissioningengineer = IfcRoleEnum.COMISSIONINGENGINEER + + +engineer = IfcRoleEnum.ENGINEER + + +owner = IfcRoleEnum.OWNER + + +consultant = IfcRoleEnum.CONSULTANT + + +constructionmanager = IfcRoleEnum.CONSTRUCTIONMANAGER + + +fieldconstructionmanager = IfcRoleEnum.FIELDCONSTRUCTIONMANAGER + + +reseller = IfcRoleEnum.RESELLER + + +userdefined = IfcRoleEnum.USERDEFINED + + +IfcRoofTypeEnum = enum_namespace() + + +flat_roof = IfcRoofTypeEnum.FLAT_ROOF + + +shed_roof = IfcRoofTypeEnum.SHED_ROOF + + +gable_roof = IfcRoofTypeEnum.GABLE_ROOF + + +hip_roof = IfcRoofTypeEnum.HIP_ROOF + + +hipped_gable_roof = IfcRoofTypeEnum.HIPPED_GABLE_ROOF + + +gambrel_roof = IfcRoofTypeEnum.GAMBREL_ROOF + + +mansard_roof = IfcRoofTypeEnum.MANSARD_ROOF + + +barrel_roof = IfcRoofTypeEnum.BARREL_ROOF + + +rainbow_roof = IfcRoofTypeEnum.RAINBOW_ROOF + + +butterfly_roof = IfcRoofTypeEnum.BUTTERFLY_ROOF + + +pavilion_roof = IfcRoofTypeEnum.PAVILION_ROOF + + +dome_roof = IfcRoofTypeEnum.DOME_ROOF + + +freeform = IfcRoofTypeEnum.FREEFORM + + +notdefined = IfcRoofTypeEnum.NOTDEFINED + + +IfcSIPrefix = enum_namespace() + + +exa = IfcSIPrefix.EXA + + +peta = IfcSIPrefix.PETA + + +tera = IfcSIPrefix.TERA + + +giga = IfcSIPrefix.GIGA + + +mega = IfcSIPrefix.MEGA + + +kilo = IfcSIPrefix.KILO + + +hecto = IfcSIPrefix.HECTO + + +deca = IfcSIPrefix.DECA + + +deci = IfcSIPrefix.DECI + + +centi = IfcSIPrefix.CENTI + + +milli = IfcSIPrefix.MILLI + + +micro = IfcSIPrefix.MICRO + + +nano = IfcSIPrefix.NANO + + +pico = IfcSIPrefix.PICO + + +femto = IfcSIPrefix.FEMTO + + +atto = IfcSIPrefix.ATTO + + +IfcSIUnitName = enum_namespace() + + +ampere = IfcSIUnitName.AMPERE + + +becquerel = IfcSIUnitName.BECQUEREL + + +candela = IfcSIUnitName.CANDELA + + +coulomb = IfcSIUnitName.COULOMB + + +cubic_metre = IfcSIUnitName.CUBIC_METRE + + +degree_celsius = IfcSIUnitName.DEGREE_CELSIUS + + +farad = IfcSIUnitName.FARAD + + +gram = IfcSIUnitName.GRAM + + +gray = IfcSIUnitName.GRAY + + +henry = IfcSIUnitName.HENRY + + +hertz = IfcSIUnitName.HERTZ + + +joule = IfcSIUnitName.JOULE + + +kelvin = IfcSIUnitName.KELVIN + + +lumen = IfcSIUnitName.LUMEN + + +lux = IfcSIUnitName.LUX + + +metre = IfcSIUnitName.METRE + + +mole = IfcSIUnitName.MOLE + + +newton = IfcSIUnitName.NEWTON + + +ohm = IfcSIUnitName.OHM + + +pascal = IfcSIUnitName.PASCAL + + +radian = IfcSIUnitName.RADIAN + + +second = IfcSIUnitName.SECOND + + +siemens = IfcSIUnitName.SIEMENS + + +sievert = IfcSIUnitName.SIEVERT + + +square_metre = IfcSIUnitName.SQUARE_METRE + + +steradian = IfcSIUnitName.STERADIAN + + +tesla = IfcSIUnitName.TESLA + + +volt = IfcSIUnitName.VOLT + + +watt = IfcSIUnitName.WATT + + +weber = IfcSIUnitName.WEBER + + +IfcSanitaryTerminalTypeEnum = enum_namespace() + + +bath = IfcSanitaryTerminalTypeEnum.BATH + + +bidet = IfcSanitaryTerminalTypeEnum.BIDET + + +cistern = IfcSanitaryTerminalTypeEnum.CISTERN + + +shower = IfcSanitaryTerminalTypeEnum.SHOWER + + +sink = IfcSanitaryTerminalTypeEnum.SINK + + +sanitaryfountain = IfcSanitaryTerminalTypeEnum.SANITARYFOUNTAIN + + +toiletpan = IfcSanitaryTerminalTypeEnum.TOILETPAN + + +urinal = IfcSanitaryTerminalTypeEnum.URINAL + + +washhandbasin = IfcSanitaryTerminalTypeEnum.WASHHANDBASIN + + +wcseat = IfcSanitaryTerminalTypeEnum.WCSEAT + + +userdefined = IfcSanitaryTerminalTypeEnum.USERDEFINED + + +notdefined = IfcSanitaryTerminalTypeEnum.NOTDEFINED + + +IfcSectionTypeEnum = enum_namespace() + + +uniform = IfcSectionTypeEnum.UNIFORM + + +tapered = IfcSectionTypeEnum.TAPERED + + +IfcSensorTypeEnum = enum_namespace() + + +co2sensor = IfcSensorTypeEnum.CO2SENSOR + + +firesensor = IfcSensorTypeEnum.FIRESENSOR + + +flowsensor = IfcSensorTypeEnum.FLOWSENSOR + + +gassensor = IfcSensorTypeEnum.GASSENSOR + + +heatsensor = IfcSensorTypeEnum.HEATSENSOR + + +humiditysensor = IfcSensorTypeEnum.HUMIDITYSENSOR + + +lightsensor = IfcSensorTypeEnum.LIGHTSENSOR + + +moisturesensor = IfcSensorTypeEnum.MOISTURESENSOR + + +movementsensor = IfcSensorTypeEnum.MOVEMENTSENSOR + + +pressuresensor = IfcSensorTypeEnum.PRESSURESENSOR + + +smokesensor = IfcSensorTypeEnum.SMOKESENSOR + + +soundsensor = IfcSensorTypeEnum.SOUNDSENSOR + + +temperaturesensor = IfcSensorTypeEnum.TEMPERATURESENSOR + + +userdefined = IfcSensorTypeEnum.USERDEFINED + + +notdefined = IfcSensorTypeEnum.NOTDEFINED + + +IfcSequenceEnum = enum_namespace() + + +start_start = IfcSequenceEnum.START_START + + +start_finish = IfcSequenceEnum.START_FINISH + + +finish_start = IfcSequenceEnum.FINISH_START + + +finish_finish = IfcSequenceEnum.FINISH_FINISH + + +notdefined = IfcSequenceEnum.NOTDEFINED + + +IfcServiceLifeFactorTypeEnum = enum_namespace() + + +a_qualityofcomponents = IfcServiceLifeFactorTypeEnum.A_QUALITYOFCOMPONENTS + + +b_designlevel = IfcServiceLifeFactorTypeEnum.B_DESIGNLEVEL + + +c_workexecutionlevel = IfcServiceLifeFactorTypeEnum.C_WORKEXECUTIONLEVEL + + +d_indoorenvironment = IfcServiceLifeFactorTypeEnum.D_INDOORENVIRONMENT + + +e_outdoorenvironment = IfcServiceLifeFactorTypeEnum.E_OUTDOORENVIRONMENT + + +f_inuseconditions = IfcServiceLifeFactorTypeEnum.F_INUSECONDITIONS + + +g_maintenancelevel = IfcServiceLifeFactorTypeEnum.G_MAINTENANCELEVEL + + +userdefined = IfcServiceLifeFactorTypeEnum.USERDEFINED + + +notdefined = IfcServiceLifeFactorTypeEnum.NOTDEFINED + + +IfcServiceLifeTypeEnum = enum_namespace() + + +actualservicelife = IfcServiceLifeTypeEnum.ACTUALSERVICELIFE + + +expectedservicelife = IfcServiceLifeTypeEnum.EXPECTEDSERVICELIFE + + +optimisticreferenceservicelife = IfcServiceLifeTypeEnum.OPTIMISTICREFERENCESERVICELIFE + + +pessimisticreferenceservicelife = IfcServiceLifeTypeEnum.PESSIMISTICREFERENCESERVICELIFE + + +referenceservicelife = IfcServiceLifeTypeEnum.REFERENCESERVICELIFE + + +IfcSlabTypeEnum = enum_namespace() + + +floor = IfcSlabTypeEnum.FLOOR + + +roof = IfcSlabTypeEnum.ROOF + + +landing = IfcSlabTypeEnum.LANDING + + +baseslab = IfcSlabTypeEnum.BASESLAB + + +userdefined = IfcSlabTypeEnum.USERDEFINED + + +notdefined = IfcSlabTypeEnum.NOTDEFINED + + +IfcSoundScaleEnum = enum_namespace() + + +dba = IfcSoundScaleEnum.DBA + + +dbb = IfcSoundScaleEnum.DBB + + +dbc = IfcSoundScaleEnum.DBC + + +nc = IfcSoundScaleEnum.NC + + +nr = IfcSoundScaleEnum.NR + + +userdefined = IfcSoundScaleEnum.USERDEFINED + + +notdefined = IfcSoundScaleEnum.NOTDEFINED + + +IfcSpaceHeaterTypeEnum = enum_namespace() + + +sectionalradiator = IfcSpaceHeaterTypeEnum.SECTIONALRADIATOR + + +panelradiator = IfcSpaceHeaterTypeEnum.PANELRADIATOR + + +tubularradiator = IfcSpaceHeaterTypeEnum.TUBULARRADIATOR + + +convector = IfcSpaceHeaterTypeEnum.CONVECTOR + + +baseboardheater = IfcSpaceHeaterTypeEnum.BASEBOARDHEATER + + +finnedtubeunit = IfcSpaceHeaterTypeEnum.FINNEDTUBEUNIT + + +unitheater = IfcSpaceHeaterTypeEnum.UNITHEATER + + +userdefined = IfcSpaceHeaterTypeEnum.USERDEFINED + + +notdefined = IfcSpaceHeaterTypeEnum.NOTDEFINED + + +IfcSpaceTypeEnum = enum_namespace() + + +userdefined = IfcSpaceTypeEnum.USERDEFINED + + +notdefined = IfcSpaceTypeEnum.NOTDEFINED + + +IfcStackTerminalTypeEnum = enum_namespace() + + +birdcage = IfcStackTerminalTypeEnum.BIRDCAGE + + +cowl = IfcStackTerminalTypeEnum.COWL + + +rainwaterhopper = IfcStackTerminalTypeEnum.RAINWATERHOPPER + + +userdefined = IfcStackTerminalTypeEnum.USERDEFINED + + +notdefined = IfcStackTerminalTypeEnum.NOTDEFINED + + +IfcStairFlightTypeEnum = enum_namespace() + + +straight = IfcStairFlightTypeEnum.STRAIGHT + + +winder = IfcStairFlightTypeEnum.WINDER + + +spiral = IfcStairFlightTypeEnum.SPIRAL + + +curved = IfcStairFlightTypeEnum.CURVED + + +freeform = IfcStairFlightTypeEnum.FREEFORM + + +userdefined = IfcStairFlightTypeEnum.USERDEFINED + + +notdefined = IfcStairFlightTypeEnum.NOTDEFINED + + +IfcStairTypeEnum = enum_namespace() + + +straight_run_stair = IfcStairTypeEnum.STRAIGHT_RUN_STAIR + + +two_straight_run_stair = IfcStairTypeEnum.TWO_STRAIGHT_RUN_STAIR + + +quarter_winding_stair = IfcStairTypeEnum.QUARTER_WINDING_STAIR + + +quarter_turn_stair = IfcStairTypeEnum.QUARTER_TURN_STAIR + + +half_winding_stair = IfcStairTypeEnum.HALF_WINDING_STAIR + + +half_turn_stair = IfcStairTypeEnum.HALF_TURN_STAIR + + +two_quarter_winding_stair = IfcStairTypeEnum.TWO_QUARTER_WINDING_STAIR + + +two_quarter_turn_stair = IfcStairTypeEnum.TWO_QUARTER_TURN_STAIR + + +three_quarter_winding_stair = IfcStairTypeEnum.THREE_QUARTER_WINDING_STAIR + + +three_quarter_turn_stair = IfcStairTypeEnum.THREE_QUARTER_TURN_STAIR + + +spiral_stair = IfcStairTypeEnum.SPIRAL_STAIR + + +double_return_stair = IfcStairTypeEnum.DOUBLE_RETURN_STAIR + + +curved_run_stair = IfcStairTypeEnum.CURVED_RUN_STAIR + + +two_curved_run_stair = IfcStairTypeEnum.TWO_CURVED_RUN_STAIR + + +userdefined = IfcStairTypeEnum.USERDEFINED + + +notdefined = IfcStairTypeEnum.NOTDEFINED + + +IfcStateEnum = enum_namespace() + + +readwrite = IfcStateEnum.READWRITE + + +readonly = IfcStateEnum.READONLY + + +locked = IfcStateEnum.LOCKED + + +readwritelocked = IfcStateEnum.READWRITELOCKED + + +readonlylocked = IfcStateEnum.READONLYLOCKED + + +IfcStructuralCurveTypeEnum = enum_namespace() + + +rigid_joined_member = IfcStructuralCurveTypeEnum.RIGID_JOINED_MEMBER + + +pin_joined_member = IfcStructuralCurveTypeEnum.PIN_JOINED_MEMBER + + +cable = IfcStructuralCurveTypeEnum.CABLE + + +tension_member = IfcStructuralCurveTypeEnum.TENSION_MEMBER + + +compression_member = IfcStructuralCurveTypeEnum.COMPRESSION_MEMBER + + +userdefined = IfcStructuralCurveTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceTypeEnum = enum_namespace() + + +bending_element = IfcStructuralSurfaceTypeEnum.BENDING_ELEMENT + + +membrane_element = IfcStructuralSurfaceTypeEnum.MEMBRANE_ELEMENT + + +shell = IfcStructuralSurfaceTypeEnum.SHELL + + +userdefined = IfcStructuralSurfaceTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceTypeEnum.NOTDEFINED + + +IfcSurfaceSide = enum_namespace() + + +positive = IfcSurfaceSide.POSITIVE + + +negative = IfcSurfaceSide.NEGATIVE + + +both = IfcSurfaceSide.BOTH + + +IfcSurfaceTextureEnum = enum_namespace() + + +bump = IfcSurfaceTextureEnum.BUMP + + +opacity = IfcSurfaceTextureEnum.OPACITY + + +reflection = IfcSurfaceTextureEnum.REFLECTION + + +selfillumination = IfcSurfaceTextureEnum.SELFILLUMINATION + + +shininess = IfcSurfaceTextureEnum.SHININESS + + +specular = IfcSurfaceTextureEnum.SPECULAR + + +texture = IfcSurfaceTextureEnum.TEXTURE + + +transparencymap = IfcSurfaceTextureEnum.TRANSPARENCYMAP + + +notdefined = IfcSurfaceTextureEnum.NOTDEFINED + + +IfcSwitchingDeviceTypeEnum = enum_namespace() + + +contactor = IfcSwitchingDeviceTypeEnum.CONTACTOR + + +emergencystop = IfcSwitchingDeviceTypeEnum.EMERGENCYSTOP + + +starter = IfcSwitchingDeviceTypeEnum.STARTER + + +switchdisconnector = IfcSwitchingDeviceTypeEnum.SWITCHDISCONNECTOR + + +toggleswitch = IfcSwitchingDeviceTypeEnum.TOGGLESWITCH + + +userdefined = IfcSwitchingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSwitchingDeviceTypeEnum.NOTDEFINED + + +IfcTankTypeEnum = enum_namespace() + + +preformed = IfcTankTypeEnum.PREFORMED + + +sectional = IfcTankTypeEnum.SECTIONAL + + +expansion = IfcTankTypeEnum.EXPANSION + + +pressurevessel = IfcTankTypeEnum.PRESSUREVESSEL + + +userdefined = IfcTankTypeEnum.USERDEFINED + + +notdefined = IfcTankTypeEnum.NOTDEFINED + + +IfcTendonTypeEnum = enum_namespace() + + +strand = IfcTendonTypeEnum.STRAND + + +wire = IfcTendonTypeEnum.WIRE + + +bar = IfcTendonTypeEnum.BAR + + +coated = IfcTendonTypeEnum.COATED + + +userdefined = IfcTendonTypeEnum.USERDEFINED + + +notdefined = IfcTendonTypeEnum.NOTDEFINED + + +IfcTextPath = enum_namespace() + + +left = IfcTextPath.LEFT + + +right = IfcTextPath.RIGHT + + +up = IfcTextPath.UP + + +down = IfcTextPath.DOWN + + +IfcThermalLoadSourceEnum = enum_namespace() + + +people = IfcThermalLoadSourceEnum.PEOPLE + + +lighting = IfcThermalLoadSourceEnum.LIGHTING + + +equipment = IfcThermalLoadSourceEnum.EQUIPMENT + + +ventilationindoorair = IfcThermalLoadSourceEnum.VENTILATIONINDOORAIR + + +ventilationoutsideair = IfcThermalLoadSourceEnum.VENTILATIONOUTSIDEAIR + + +recirculatedair = IfcThermalLoadSourceEnum.RECIRCULATEDAIR + + +exhaustair = IfcThermalLoadSourceEnum.EXHAUSTAIR + + +airexchangerate = IfcThermalLoadSourceEnum.AIREXCHANGERATE + + +drybulbtemperature = IfcThermalLoadSourceEnum.DRYBULBTEMPERATURE + + +relativehumidity = IfcThermalLoadSourceEnum.RELATIVEHUMIDITY + + +infiltration = IfcThermalLoadSourceEnum.INFILTRATION + + +userdefined = IfcThermalLoadSourceEnum.USERDEFINED + + +notdefined = IfcThermalLoadSourceEnum.NOTDEFINED + + +IfcThermalLoadTypeEnum = enum_namespace() + + +sensible = IfcThermalLoadTypeEnum.SENSIBLE + + +latent = IfcThermalLoadTypeEnum.LATENT + + +radiant = IfcThermalLoadTypeEnum.RADIANT + + +notdefined = IfcThermalLoadTypeEnum.NOTDEFINED + + +IfcTimeSeriesDataTypeEnum = enum_namespace() + + +continuous = IfcTimeSeriesDataTypeEnum.CONTINUOUS + + +discrete = IfcTimeSeriesDataTypeEnum.DISCRETE + + +discretebinary = IfcTimeSeriesDataTypeEnum.DISCRETEBINARY + + +piecewisebinary = IfcTimeSeriesDataTypeEnum.PIECEWISEBINARY + + +piecewiseconstant = IfcTimeSeriesDataTypeEnum.PIECEWISECONSTANT + + +piecewisecontinuous = IfcTimeSeriesDataTypeEnum.PIECEWISECONTINUOUS + + +notdefined = IfcTimeSeriesDataTypeEnum.NOTDEFINED + + +IfcTimeSeriesScheduleTypeEnum = enum_namespace() + + +annual = IfcTimeSeriesScheduleTypeEnum.ANNUAL + + +monthly = IfcTimeSeriesScheduleTypeEnum.MONTHLY + + +weekly = IfcTimeSeriesScheduleTypeEnum.WEEKLY + + +daily = IfcTimeSeriesScheduleTypeEnum.DAILY + + +userdefined = IfcTimeSeriesScheduleTypeEnum.USERDEFINED + + +notdefined = IfcTimeSeriesScheduleTypeEnum.NOTDEFINED + + +IfcTransformerTypeEnum = enum_namespace() + + +current = IfcTransformerTypeEnum.CURRENT + + +frequency = IfcTransformerTypeEnum.FREQUENCY + + +voltage = IfcTransformerTypeEnum.VOLTAGE + + +userdefined = IfcTransformerTypeEnum.USERDEFINED + + +notdefined = IfcTransformerTypeEnum.NOTDEFINED + + +IfcTransitionCode = enum_namespace() + + +discontinuous = IfcTransitionCode.DISCONTINUOUS + + +continuous = IfcTransitionCode.CONTINUOUS + + +contsamegradient = IfcTransitionCode.CONTSAMEGRADIENT + + +contsamegradientsamecurvature = IfcTransitionCode.CONTSAMEGRADIENTSAMECURVATURE + + +IfcTransportElementTypeEnum = enum_namespace() + + +elevator = IfcTransportElementTypeEnum.ELEVATOR + + +escalator = IfcTransportElementTypeEnum.ESCALATOR + + +movingwalkway = IfcTransportElementTypeEnum.MOVINGWALKWAY + + +userdefined = IfcTransportElementTypeEnum.USERDEFINED + + +notdefined = IfcTransportElementTypeEnum.NOTDEFINED + + +IfcTrimmingPreference = enum_namespace() + + +cartesian = IfcTrimmingPreference.CARTESIAN + + +parameter = IfcTrimmingPreference.PARAMETER + + +unspecified = IfcTrimmingPreference.UNSPECIFIED + + +IfcTubeBundleTypeEnum = enum_namespace() + + +finned = IfcTubeBundleTypeEnum.FINNED + + +userdefined = IfcTubeBundleTypeEnum.USERDEFINED + + +notdefined = IfcTubeBundleTypeEnum.NOTDEFINED + + +IfcUnitEnum = enum_namespace() + + +absorbeddoseunit = IfcUnitEnum.ABSORBEDDOSEUNIT + + +amountofsubstanceunit = IfcUnitEnum.AMOUNTOFSUBSTANCEUNIT + + +areaunit = IfcUnitEnum.AREAUNIT + + +doseequivalentunit = IfcUnitEnum.DOSEEQUIVALENTUNIT + + +electriccapacitanceunit = IfcUnitEnum.ELECTRICCAPACITANCEUNIT + + +electricchargeunit = IfcUnitEnum.ELECTRICCHARGEUNIT + + +electricconductanceunit = IfcUnitEnum.ELECTRICCONDUCTANCEUNIT + + +electriccurrentunit = IfcUnitEnum.ELECTRICCURRENTUNIT + + +electricresistanceunit = IfcUnitEnum.ELECTRICRESISTANCEUNIT + + +electricvoltageunit = IfcUnitEnum.ELECTRICVOLTAGEUNIT + + +energyunit = IfcUnitEnum.ENERGYUNIT + + +forceunit = IfcUnitEnum.FORCEUNIT + + +frequencyunit = IfcUnitEnum.FREQUENCYUNIT + + +illuminanceunit = IfcUnitEnum.ILLUMINANCEUNIT + + +inductanceunit = IfcUnitEnum.INDUCTANCEUNIT + + +lengthunit = IfcUnitEnum.LENGTHUNIT + + +luminousfluxunit = IfcUnitEnum.LUMINOUSFLUXUNIT + + +luminousintensityunit = IfcUnitEnum.LUMINOUSINTENSITYUNIT + + +magneticfluxdensityunit = IfcUnitEnum.MAGNETICFLUXDENSITYUNIT + + +magneticfluxunit = IfcUnitEnum.MAGNETICFLUXUNIT + + +massunit = IfcUnitEnum.MASSUNIT + + +planeangleunit = IfcUnitEnum.PLANEANGLEUNIT + + +powerunit = IfcUnitEnum.POWERUNIT + + +pressureunit = IfcUnitEnum.PRESSUREUNIT + + +radioactivityunit = IfcUnitEnum.RADIOACTIVITYUNIT + + +solidangleunit = IfcUnitEnum.SOLIDANGLEUNIT + + +thermodynamictemperatureunit = IfcUnitEnum.THERMODYNAMICTEMPERATUREUNIT + + +timeunit = IfcUnitEnum.TIMEUNIT + + +volumeunit = IfcUnitEnum.VOLUMEUNIT + + +userdefined = IfcUnitEnum.USERDEFINED + + +IfcUnitaryEquipmentTypeEnum = enum_namespace() + + +airhandler = IfcUnitaryEquipmentTypeEnum.AIRHANDLER + + +airconditioningunit = IfcUnitaryEquipmentTypeEnum.AIRCONDITIONINGUNIT + + +splitsystem = IfcUnitaryEquipmentTypeEnum.SPLITSYSTEM + + +rooftopunit = IfcUnitaryEquipmentTypeEnum.ROOFTOPUNIT + + +userdefined = IfcUnitaryEquipmentTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryEquipmentTypeEnum.NOTDEFINED + + +IfcValveTypeEnum = enum_namespace() + + +airrelease = IfcValveTypeEnum.AIRRELEASE + + +antivacuum = IfcValveTypeEnum.ANTIVACUUM + + +changeover = IfcValveTypeEnum.CHANGEOVER + + +check = IfcValveTypeEnum.CHECK + + +commissioning = IfcValveTypeEnum.COMMISSIONING + + +diverting = IfcValveTypeEnum.DIVERTING + + +drawoffcock = IfcValveTypeEnum.DRAWOFFCOCK + + +doublecheck = IfcValveTypeEnum.DOUBLECHECK + + +doubleregulating = IfcValveTypeEnum.DOUBLEREGULATING + + +faucet = IfcValveTypeEnum.FAUCET + + +flushing = IfcValveTypeEnum.FLUSHING + + +gascock = IfcValveTypeEnum.GASCOCK + + +gastap = IfcValveTypeEnum.GASTAP + + +isolating = IfcValveTypeEnum.ISOLATING + + +mixing = IfcValveTypeEnum.MIXING + + +pressurereducing = IfcValveTypeEnum.PRESSUREREDUCING + + +pressurerelief = IfcValveTypeEnum.PRESSURERELIEF + + +regulating = IfcValveTypeEnum.REGULATING + + +safetycutoff = IfcValveTypeEnum.SAFETYCUTOFF + + +steamtrap = IfcValveTypeEnum.STEAMTRAP + + +stopcock = IfcValveTypeEnum.STOPCOCK + + +userdefined = IfcValveTypeEnum.USERDEFINED + + +notdefined = IfcValveTypeEnum.NOTDEFINED + + +IfcVibrationIsolatorTypeEnum = enum_namespace() + + +compression = IfcVibrationIsolatorTypeEnum.COMPRESSION + + +spring = IfcVibrationIsolatorTypeEnum.SPRING + + +userdefined = IfcVibrationIsolatorTypeEnum.USERDEFINED + + +notdefined = IfcVibrationIsolatorTypeEnum.NOTDEFINED + + +IfcWallTypeEnum = enum_namespace() + + +standard = IfcWallTypeEnum.STANDARD + + +polygonal = IfcWallTypeEnum.POLYGONAL + + +shear = IfcWallTypeEnum.SHEAR + + +elementedwall = IfcWallTypeEnum.ELEMENTEDWALL + + +plumbingwall = IfcWallTypeEnum.PLUMBINGWALL + + +userdefined = IfcWallTypeEnum.USERDEFINED + + +notdefined = IfcWallTypeEnum.NOTDEFINED + + +IfcWasteTerminalTypeEnum = enum_namespace() + + +floortrap = IfcWasteTerminalTypeEnum.FLOORTRAP + + +floorwaste = IfcWasteTerminalTypeEnum.FLOORWASTE + + +gullysump = IfcWasteTerminalTypeEnum.GULLYSUMP + + +gullytrap = IfcWasteTerminalTypeEnum.GULLYTRAP + + +greaseinterceptor = IfcWasteTerminalTypeEnum.GREASEINTERCEPTOR + + +oilinterceptor = IfcWasteTerminalTypeEnum.OILINTERCEPTOR + + +petrolinterceptor = IfcWasteTerminalTypeEnum.PETROLINTERCEPTOR + + +roofdrain = IfcWasteTerminalTypeEnum.ROOFDRAIN + + +wastedisposalunit = IfcWasteTerminalTypeEnum.WASTEDISPOSALUNIT + + +wastetrap = IfcWasteTerminalTypeEnum.WASTETRAP + + +userdefined = IfcWasteTerminalTypeEnum.USERDEFINED + + +notdefined = IfcWasteTerminalTypeEnum.NOTDEFINED + + +IfcWindowPanelOperationEnum = enum_namespace() + + +sidehungrighthand = IfcWindowPanelOperationEnum.SIDEHUNGRIGHTHAND + + +sidehunglefthand = IfcWindowPanelOperationEnum.SIDEHUNGLEFTHAND + + +tiltandturnrighthand = IfcWindowPanelOperationEnum.TILTANDTURNRIGHTHAND + + +tiltandturnlefthand = IfcWindowPanelOperationEnum.TILTANDTURNLEFTHAND + + +tophung = IfcWindowPanelOperationEnum.TOPHUNG + + +bottomhung = IfcWindowPanelOperationEnum.BOTTOMHUNG + + +pivothorizontal = IfcWindowPanelOperationEnum.PIVOTHORIZONTAL + + +pivotvertical = IfcWindowPanelOperationEnum.PIVOTVERTICAL + + +slidinghorizontal = IfcWindowPanelOperationEnum.SLIDINGHORIZONTAL + + +slidingvertical = IfcWindowPanelOperationEnum.SLIDINGVERTICAL + + +removablecasement = IfcWindowPanelOperationEnum.REMOVABLECASEMENT + + +fixedcasement = IfcWindowPanelOperationEnum.FIXEDCASEMENT + + +otheroperation = IfcWindowPanelOperationEnum.OTHEROPERATION + + +notdefined = IfcWindowPanelOperationEnum.NOTDEFINED + + +IfcWindowPanelPositionEnum = enum_namespace() + + +left = IfcWindowPanelPositionEnum.LEFT + + +middle = IfcWindowPanelPositionEnum.MIDDLE + + +right = IfcWindowPanelPositionEnum.RIGHT + + +bottom = IfcWindowPanelPositionEnum.BOTTOM + + +top = IfcWindowPanelPositionEnum.TOP + + +notdefined = IfcWindowPanelPositionEnum.NOTDEFINED + + +IfcWindowStyleConstructionEnum = enum_namespace() + + +aluminium = IfcWindowStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcWindowStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcWindowStyleConstructionEnum.STEEL + + +wood = IfcWindowStyleConstructionEnum.WOOD + + +aluminium_wood = IfcWindowStyleConstructionEnum.ALUMINIUM_WOOD + + +plastic = IfcWindowStyleConstructionEnum.PLASTIC + + +other_construction = IfcWindowStyleConstructionEnum.OTHER_CONSTRUCTION + + +notdefined = IfcWindowStyleConstructionEnum.NOTDEFINED + + +IfcWindowStyleOperationEnum = enum_namespace() + + +single_panel = IfcWindowStyleOperationEnum.SINGLE_PANEL + + +double_panel_vertical = IfcWindowStyleOperationEnum.DOUBLE_PANEL_VERTICAL + + +double_panel_horizontal = IfcWindowStyleOperationEnum.DOUBLE_PANEL_HORIZONTAL + + +triple_panel_vertical = IfcWindowStyleOperationEnum.TRIPLE_PANEL_VERTICAL + + +triple_panel_bottom = IfcWindowStyleOperationEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_top = IfcWindowStyleOperationEnum.TRIPLE_PANEL_TOP + + +triple_panel_left = IfcWindowStyleOperationEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowStyleOperationEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_horizontal = IfcWindowStyleOperationEnum.TRIPLE_PANEL_HORIZONTAL + + +userdefined = IfcWindowStyleOperationEnum.USERDEFINED + + +notdefined = IfcWindowStyleOperationEnum.NOTDEFINED + + +IfcWorkControlTypeEnum = enum_namespace() + + +actual = IfcWorkControlTypeEnum.ACTUAL + + +baseline = IfcWorkControlTypeEnum.BASELINE + + +planned = IfcWorkControlTypeEnum.PLANNED + + +userdefined = IfcWorkControlTypeEnum.USERDEFINED + + +notdefined = IfcWorkControlTypeEnum.NOTDEFINED + + +def Ifc2DCompositeCurve(*args, **kwargs): return ifcopenshell.create_entity('Ifc2DCompositeCurve', 'IFC2X3', *args, **kwargs) + + +def IfcActionRequest(*args, **kwargs): return ifcopenshell.create_entity('IfcActionRequest', 'IFC2X3', *args, **kwargs) + + +def IfcActor(*args, **kwargs): return ifcopenshell.create_entity('IfcActor', 'IFC2X3', *args, **kwargs) + + +def IfcActorRole(*args, **kwargs): return ifcopenshell.create_entity('IfcActorRole', 'IFC2X3', *args, **kwargs) + + +def IfcActuatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcActuatorType', 'IFC2X3', *args, **kwargs) + + +def IfcAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcAddress', 'IFC2X3', *args, **kwargs) + + +def IfcAirTerminalBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBoxType', 'IFC2X3', *args, **kwargs) + + +def IfcAirTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalType', 'IFC2X3', *args, **kwargs) + + +def IfcAirToAirHeatRecoveryType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecoveryType', 'IFC2X3', *args, **kwargs) + + +def IfcAlarmType(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarmType', 'IFC2X3', *args, **kwargs) + + +def IfcAngularDimension(*args, **kwargs): return ifcopenshell.create_entity('IfcAngularDimension', 'IFC2X3', *args, **kwargs) + + +def IfcAnnotation(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotation', 'IFC2X3', *args, **kwargs) + + +def IfcAnnotationCurveOccurrence(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationCurveOccurrence', 'IFC2X3', *args, **kwargs) + + +def IfcAnnotationFillArea(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationFillArea', 'IFC2X3', *args, **kwargs) + + +def IfcAnnotationFillAreaOccurrence(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationFillAreaOccurrence', 'IFC2X3', *args, **kwargs) + + +def IfcAnnotationOccurrence(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationOccurrence', 'IFC2X3', *args, **kwargs) + + +def IfcAnnotationSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationSurface', 'IFC2X3', *args, **kwargs) + + +def IfcAnnotationSurfaceOccurrence(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationSurfaceOccurrence', 'IFC2X3', *args, **kwargs) + + +def IfcAnnotationSymbolOccurrence(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationSymbolOccurrence', 'IFC2X3', *args, **kwargs) + + +def IfcAnnotationTextOccurrence(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationTextOccurrence', 'IFC2X3', *args, **kwargs) + + +def IfcApplication(*args, **kwargs): return ifcopenshell.create_entity('IfcApplication', 'IFC2X3', *args, **kwargs) + + +def IfcAppliedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcAppliedValue', 'IFC2X3', *args, **kwargs) + + +def IfcAppliedValueRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcAppliedValueRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcApproval', 'IFC2X3', *args, **kwargs) + + +def IfcApprovalActorRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcApprovalActorRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcApprovalPropertyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcApprovalPropertyRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcApprovalRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcArbitraryClosedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryClosedProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcArbitraryOpenProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryOpenProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcArbitraryProfileDefWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryProfileDefWithVoids', 'IFC2X3', *args, **kwargs) + + +def IfcAsset(*args, **kwargs): return ifcopenshell.create_entity('IfcAsset', 'IFC2X3', *args, **kwargs) + + +def IfcAsymmetricIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcAsymmetricIShapeProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcAxis1Placement(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis1Placement', 'IFC2X3', *args, **kwargs) + + +def IfcAxis2Placement2D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement2D', 'IFC2X3', *args, **kwargs) + + +def IfcAxis2Placement3D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement3D', 'IFC2X3', *args, **kwargs) + + +def IfcBSplineCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurve', 'IFC2X3', *args, **kwargs) + + +def IfcBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcBeam', 'IFC2X3', *args, **kwargs) + + +def IfcBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamType', 'IFC2X3', *args, **kwargs) + + +def IfcBezierCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBezierCurve', 'IFC2X3', *args, **kwargs) + + +def IfcBlobTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcBlobTexture', 'IFC2X3', *args, **kwargs) + + +def IfcBlock(*args, **kwargs): return ifcopenshell.create_entity('IfcBlock', 'IFC2X3', *args, **kwargs) + + +def IfcBoilerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBoilerType', 'IFC2X3', *args, **kwargs) + + +def IfcBooleanClippingResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanClippingResult', 'IFC2X3', *args, **kwargs) + + +def IfcBooleanResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanResult', 'IFC2X3', *args, **kwargs) + + +def IfcBoundaryCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCondition', 'IFC2X3', *args, **kwargs) + + +def IfcBoundaryEdgeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryEdgeCondition', 'IFC2X3', *args, **kwargs) + + +def IfcBoundaryFaceCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryFaceCondition', 'IFC2X3', *args, **kwargs) + + +def IfcBoundaryNodeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeCondition', 'IFC2X3', *args, **kwargs) + + +def IfcBoundaryNodeConditionWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeConditionWarping', 'IFC2X3', *args, **kwargs) + + +def IfcBoundedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedCurve', 'IFC2X3', *args, **kwargs) + + +def IfcBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedSurface', 'IFC2X3', *args, **kwargs) + + +def IfcBoundingBox(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundingBox', 'IFC2X3', *args, **kwargs) + + +def IfcBoxedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcBoxedHalfSpace', 'IFC2X3', *args, **kwargs) + + +def IfcBuilding(*args, **kwargs): return ifcopenshell.create_entity('IfcBuilding', 'IFC2X3', *args, **kwargs) + + +def IfcBuildingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElement', 'IFC2X3', *args, **kwargs) + + +def IfcBuildingElementComponent(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementComponent', 'IFC2X3', *args, **kwargs) + + +def IfcBuildingElementPart(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPart', 'IFC2X3', *args, **kwargs) + + +def IfcBuildingElementProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxy', 'IFC2X3', *args, **kwargs) + + +def IfcBuildingElementProxyType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxyType', 'IFC2X3', *args, **kwargs) + + +def IfcBuildingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementType', 'IFC2X3', *args, **kwargs) + + +def IfcBuildingStorey(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingStorey', 'IFC2X3', *args, **kwargs) + + +def IfcCShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCShapeProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcCableCarrierFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFittingType', 'IFC2X3', *args, **kwargs) + + +def IfcCableCarrierSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegmentType', 'IFC2X3', *args, **kwargs) + + +def IfcCableSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegmentType', 'IFC2X3', *args, **kwargs) + + +def IfcCalendarDate(*args, **kwargs): return ifcopenshell.create_entity('IfcCalendarDate', 'IFC2X3', *args, **kwargs) + + +def IfcCartesianPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPoint', 'IFC2X3', *args, **kwargs) + + +def IfcCartesianTransformationOperator(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator', 'IFC2X3', *args, **kwargs) + + +def IfcCartesianTransformationOperator2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2D', 'IFC2X3', *args, **kwargs) + + +def IfcCartesianTransformationOperator2DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2DnonUniform', 'IFC2X3', *args, **kwargs) + + +def IfcCartesianTransformationOperator3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3D', 'IFC2X3', *args, **kwargs) + + +def IfcCartesianTransformationOperator3DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3DnonUniform', 'IFC2X3', *args, **kwargs) + + +def IfcCenterLineProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCenterLineProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcChamferEdgeFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcChamferEdgeFeature', 'IFC2X3', *args, **kwargs) + + +def IfcChillerType(*args, **kwargs): return ifcopenshell.create_entity('IfcChillerType', 'IFC2X3', *args, **kwargs) + + +def IfcCircle(*args, **kwargs): return ifcopenshell.create_entity('IfcCircle', 'IFC2X3', *args, **kwargs) + + +def IfcCircleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleHollowProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcCircleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcClassification', 'IFC2X3', *args, **kwargs) + + +def IfcClassificationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcClassificationItem', 'IFC2X3', *args, **kwargs) + + +def IfcClassificationItemRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcClassificationItemRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcClassificationNotation(*args, **kwargs): return ifcopenshell.create_entity('IfcClassificationNotation', 'IFC2X3', *args, **kwargs) + + +def IfcClassificationNotationFacet(*args, **kwargs): return ifcopenshell.create_entity('IfcClassificationNotationFacet', 'IFC2X3', *args, **kwargs) + + +def IfcClassificationReference(*args, **kwargs): return ifcopenshell.create_entity('IfcClassificationReference', 'IFC2X3', *args, **kwargs) + + +def IfcClosedShell(*args, **kwargs): return ifcopenshell.create_entity('IfcClosedShell', 'IFC2X3', *args, **kwargs) + + +def IfcCoilType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoilType', 'IFC2X3', *args, **kwargs) + + +def IfcColourRgb(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgb', 'IFC2X3', *args, **kwargs) + + +def IfcColourSpecification(*args, **kwargs): return ifcopenshell.create_entity('IfcColourSpecification', 'IFC2X3', *args, **kwargs) + + +def IfcColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcColumn', 'IFC2X3', *args, **kwargs) + + +def IfcColumnType(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnType', 'IFC2X3', *args, **kwargs) + + +def IfcComplexProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexProperty', 'IFC2X3', *args, **kwargs) + + +def IfcCompositeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurve', 'IFC2X3', *args, **kwargs) + + +def IfcCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveSegment', 'IFC2X3', *args, **kwargs) + + +def IfcCompositeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcCompressorType(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressorType', 'IFC2X3', *args, **kwargs) + + +def IfcCondenserType(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenserType', 'IFC2X3', *args, **kwargs) + + +def IfcCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcCondition', 'IFC2X3', *args, **kwargs) + + +def IfcConditionCriterion(*args, **kwargs): return ifcopenshell.create_entity('IfcConditionCriterion', 'IFC2X3', *args, **kwargs) + + +def IfcConic(*args, **kwargs): return ifcopenshell.create_entity('IfcConic', 'IFC2X3', *args, **kwargs) + + +def IfcConnectedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectedFaceSet', 'IFC2X3', *args, **kwargs) + + +def IfcConnectionCurveGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionCurveGeometry', 'IFC2X3', *args, **kwargs) + + +def IfcConnectionGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionGeometry', 'IFC2X3', *args, **kwargs) + + +def IfcConnectionPointEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointEccentricity', 'IFC2X3', *args, **kwargs) + + +def IfcConnectionPointGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointGeometry', 'IFC2X3', *args, **kwargs) + + +def IfcConnectionPortGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPortGeometry', 'IFC2X3', *args, **kwargs) + + +def IfcConnectionSurfaceGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionSurfaceGeometry', 'IFC2X3', *args, **kwargs) + + +def IfcConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcConstraint', 'IFC2X3', *args, **kwargs) + + +def IfcConstraintAggregationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcConstraintAggregationRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcConstraintClassificationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcConstraintClassificationRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcConstraintRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcConstraintRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcConstructionEquipmentResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResource', 'IFC2X3', *args, **kwargs) + + +def IfcConstructionMaterialResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResource', 'IFC2X3', *args, **kwargs) + + +def IfcConstructionProductResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResource', 'IFC2X3', *args, **kwargs) + + +def IfcConstructionResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResource', 'IFC2X3', *args, **kwargs) + + +def IfcContextDependentUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcContextDependentUnit', 'IFC2X3', *args, **kwargs) + + +def IfcControl(*args, **kwargs): return ifcopenshell.create_entity('IfcControl', 'IFC2X3', *args, **kwargs) + + +def IfcControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcControllerType', 'IFC2X3', *args, **kwargs) + + +def IfcConversionBasedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnit', 'IFC2X3', *args, **kwargs) + + +def IfcCooledBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeamType', 'IFC2X3', *args, **kwargs) + + +def IfcCoolingTowerType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTowerType', 'IFC2X3', *args, **kwargs) + + +def IfcCoordinatedUniversalTimeOffset(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinatedUniversalTimeOffset', 'IFC2X3', *args, **kwargs) + + +def IfcCostItem(*args, **kwargs): return ifcopenshell.create_entity('IfcCostItem', 'IFC2X3', *args, **kwargs) + + +def IfcCostSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcCostSchedule', 'IFC2X3', *args, **kwargs) + + +def IfcCostValue(*args, **kwargs): return ifcopenshell.create_entity('IfcCostValue', 'IFC2X3', *args, **kwargs) + + +def IfcCovering(*args, **kwargs): return ifcopenshell.create_entity('IfcCovering', 'IFC2X3', *args, **kwargs) + + +def IfcCoveringType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoveringType', 'IFC2X3', *args, **kwargs) + + +def IfcCraneRailAShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCraneRailAShapeProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcCraneRailFShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCraneRailFShapeProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcCrewResource(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResource', 'IFC2X3', *args, **kwargs) + + +def IfcCsgPrimitive3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgPrimitive3D', 'IFC2X3', *args, **kwargs) + + +def IfcCsgSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgSolid', 'IFC2X3', *args, **kwargs) + + +def IfcCurrencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcCurrencyRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcCurtainWall(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWall', 'IFC2X3', *args, **kwargs) + + +def IfcCurtainWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWallType', 'IFC2X3', *args, **kwargs) + + +def IfcCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCurve', 'IFC2X3', *args, **kwargs) + + +def IfcCurveBoundedPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedPlane', 'IFC2X3', *args, **kwargs) + + +def IfcCurveStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyle', 'IFC2X3', *args, **kwargs) + + +def IfcCurveStyleFont(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFont', 'IFC2X3', *args, **kwargs) + + +def IfcCurveStyleFontAndScaling(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontAndScaling', 'IFC2X3', *args, **kwargs) + + +def IfcCurveStyleFontPattern(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontPattern', 'IFC2X3', *args, **kwargs) + + +def IfcDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcDamperType', 'IFC2X3', *args, **kwargs) + + +def IfcDateAndTime(*args, **kwargs): return ifcopenshell.create_entity('IfcDateAndTime', 'IFC2X3', *args, **kwargs) + + +def IfcDefinedSymbol(*args, **kwargs): return ifcopenshell.create_entity('IfcDefinedSymbol', 'IFC2X3', *args, **kwargs) + + +def IfcDerivedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcDerivedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnit', 'IFC2X3', *args, **kwargs) + + +def IfcDerivedUnitElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnitElement', 'IFC2X3', *args, **kwargs) + + +def IfcDiameterDimension(*args, **kwargs): return ifcopenshell.create_entity('IfcDiameterDimension', 'IFC2X3', *args, **kwargs) + + +def IfcDimensionCalloutRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionCalloutRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcDimensionCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionCurve', 'IFC2X3', *args, **kwargs) + + +def IfcDimensionCurveDirectedCallout(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionCurveDirectedCallout', 'IFC2X3', *args, **kwargs) + + +def IfcDimensionCurveTerminator(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionCurveTerminator', 'IFC2X3', *args, **kwargs) + + +def IfcDimensionPair(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionPair', 'IFC2X3', *args, **kwargs) + + +def IfcDimensionalExponents(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionalExponents', 'IFC2X3', *args, **kwargs) + + +def IfcDirection(*args, **kwargs): return ifcopenshell.create_entity('IfcDirection', 'IFC2X3', *args, **kwargs) + + +def IfcDiscreteAccessory(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessory', 'IFC2X3', *args, **kwargs) + + +def IfcDiscreteAccessoryType(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessoryType', 'IFC2X3', *args, **kwargs) + + +def IfcDistributionChamberElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElement', 'IFC2X3', *args, **kwargs) + + +def IfcDistributionChamberElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElementType', 'IFC2X3', *args, **kwargs) + + +def IfcDistributionControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElement', 'IFC2X3', *args, **kwargs) + + +def IfcDistributionControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElementType', 'IFC2X3', *args, **kwargs) + + +def IfcDistributionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElement', 'IFC2X3', *args, **kwargs) + + +def IfcDistributionElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElementType', 'IFC2X3', *args, **kwargs) + + +def IfcDistributionFlowElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElement', 'IFC2X3', *args, **kwargs) + + +def IfcDistributionFlowElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElementType', 'IFC2X3', *args, **kwargs) + + +def IfcDistributionPort(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionPort', 'IFC2X3', *args, **kwargs) + + +def IfcDocumentElectronicFormat(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentElectronicFormat', 'IFC2X3', *args, **kwargs) + + +def IfcDocumentInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformation', 'IFC2X3', *args, **kwargs) + + +def IfcDocumentInformationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformationRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcDocumentReference(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentReference', 'IFC2X3', *args, **kwargs) + + +def IfcDoor(*args, **kwargs): return ifcopenshell.create_entity('IfcDoor', 'IFC2X3', *args, **kwargs) + + +def IfcDoorLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorLiningProperties', 'IFC2X3', *args, **kwargs) + + +def IfcDoorPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorPanelProperties', 'IFC2X3', *args, **kwargs) + + +def IfcDoorStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorStyle', 'IFC2X3', *args, **kwargs) + + +def IfcDraughtingCallout(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingCallout', 'IFC2X3', *args, **kwargs) + + +def IfcDraughtingCalloutRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingCalloutRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcDraughtingPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedColour', 'IFC2X3', *args, **kwargs) + + +def IfcDraughtingPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedCurveFont', 'IFC2X3', *args, **kwargs) + + +def IfcDraughtingPreDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedTextFont', 'IFC2X3', *args, **kwargs) + + +def IfcDuctFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFittingType', 'IFC2X3', *args, **kwargs) + + +def IfcDuctSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegmentType', 'IFC2X3', *args, **kwargs) + + +def IfcDuctSilencerType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencerType', 'IFC2X3', *args, **kwargs) + + +def IfcEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcEdge', 'IFC2X3', *args, **kwargs) + + +def IfcEdgeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeCurve', 'IFC2X3', *args, **kwargs) + + +def IfcEdgeFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeFeature', 'IFC2X3', *args, **kwargs) + + +def IfcEdgeLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeLoop', 'IFC2X3', *args, **kwargs) + + +def IfcElectricApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricApplianceType', 'IFC2X3', *args, **kwargs) + + +def IfcElectricDistributionPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionPoint', 'IFC2X3', *args, **kwargs) + + +def IfcElectricFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDeviceType', 'IFC2X3', *args, **kwargs) + + +def IfcElectricGeneratorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGeneratorType', 'IFC2X3', *args, **kwargs) + + +def IfcElectricHeaterType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricHeaterType', 'IFC2X3', *args, **kwargs) + + +def IfcElectricMotorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotorType', 'IFC2X3', *args, **kwargs) + + +def IfcElectricTimeControlType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControlType', 'IFC2X3', *args, **kwargs) + + +def IfcElectricalBaseProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricalBaseProperties', 'IFC2X3', *args, **kwargs) + + +def IfcElectricalCircuit(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricalCircuit', 'IFC2X3', *args, **kwargs) + + +def IfcElectricalElement(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricalElement', 'IFC2X3', *args, **kwargs) + + +def IfcElement(*args, **kwargs): return ifcopenshell.create_entity('IfcElement', 'IFC2X3', *args, **kwargs) + + +def IfcElementAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssembly', 'IFC2X3', *args, **kwargs) + + +def IfcElementComponent(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponent', 'IFC2X3', *args, **kwargs) + + +def IfcElementComponentType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponentType', 'IFC2X3', *args, **kwargs) + + +def IfcElementQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcElementQuantity', 'IFC2X3', *args, **kwargs) + + +def IfcElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementType', 'IFC2X3', *args, **kwargs) + + +def IfcElementarySurface(*args, **kwargs): return ifcopenshell.create_entity('IfcElementarySurface', 'IFC2X3', *args, **kwargs) + + +def IfcEllipse(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipse', 'IFC2X3', *args, **kwargs) + + +def IfcEllipseProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipseProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcEnergyConversionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDevice', 'IFC2X3', *args, **kwargs) + + +def IfcEnergyConversionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDeviceType', 'IFC2X3', *args, **kwargs) + + +def IfcEnergyProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyProperties', 'IFC2X3', *args, **kwargs) + + +def IfcEnvironmentalImpactValue(*args, **kwargs): return ifcopenshell.create_entity('IfcEnvironmentalImpactValue', 'IFC2X3', *args, **kwargs) + + +def IfcEquipmentElement(*args, **kwargs): return ifcopenshell.create_entity('IfcEquipmentElement', 'IFC2X3', *args, **kwargs) + + +def IfcEquipmentStandard(*args, **kwargs): return ifcopenshell.create_entity('IfcEquipmentStandard', 'IFC2X3', *args, **kwargs) + + +def IfcEvaporativeCoolerType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCoolerType', 'IFC2X3', *args, **kwargs) + + +def IfcEvaporatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporatorType', 'IFC2X3', *args, **kwargs) + + +def IfcExtendedMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcExtendedMaterialProperties', 'IFC2X3', *args, **kwargs) + + +def IfcExternalReference(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReference', 'IFC2X3', *args, **kwargs) + + +def IfcExternallyDefinedHatchStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedHatchStyle', 'IFC2X3', *args, **kwargs) + + +def IfcExternallyDefinedSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedSurfaceStyle', 'IFC2X3', *args, **kwargs) + + +def IfcExternallyDefinedSymbol(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedSymbol', 'IFC2X3', *args, **kwargs) + + +def IfcExternallyDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedTextFont', 'IFC2X3', *args, **kwargs) + + +def IfcExtrudedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolid', 'IFC2X3', *args, **kwargs) + + +def IfcFace(*args, **kwargs): return ifcopenshell.create_entity('IfcFace', 'IFC2X3', *args, **kwargs) + + +def IfcFaceBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBasedSurfaceModel', 'IFC2X3', *args, **kwargs) + + +def IfcFaceBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBound', 'IFC2X3', *args, **kwargs) + + +def IfcFaceOuterBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceOuterBound', 'IFC2X3', *args, **kwargs) + + +def IfcFaceSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceSurface', 'IFC2X3', *args, **kwargs) + + +def IfcFacetedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrep', 'IFC2X3', *args, **kwargs) + + +def IfcFacetedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrepWithVoids', 'IFC2X3', *args, **kwargs) + + +def IfcFailureConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcFailureConnectionCondition', 'IFC2X3', *args, **kwargs) + + +def IfcFanType(*args, **kwargs): return ifcopenshell.create_entity('IfcFanType', 'IFC2X3', *args, **kwargs) + + +def IfcFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcFastener', 'IFC2X3', *args, **kwargs) + + +def IfcFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFastenerType', 'IFC2X3', *args, **kwargs) + + +def IfcFeatureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElement', 'IFC2X3', *args, **kwargs) + + +def IfcFeatureElementAddition(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementAddition', 'IFC2X3', *args, **kwargs) + + +def IfcFeatureElementSubtraction(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementSubtraction', 'IFC2X3', *args, **kwargs) + + +def IfcFillAreaStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyle', 'IFC2X3', *args, **kwargs) + + +def IfcFillAreaStyleHatching(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleHatching', 'IFC2X3', *args, **kwargs) + + +def IfcFillAreaStyleTileSymbolWithStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleTileSymbolWithStyle', 'IFC2X3', *args, **kwargs) + + +def IfcFillAreaStyleTiles(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleTiles', 'IFC2X3', *args, **kwargs) + + +def IfcFilterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFilterType', 'IFC2X3', *args, **kwargs) + + +def IfcFireSuppressionTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminalType', 'IFC2X3', *args, **kwargs) + + +def IfcFlowController(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowController', 'IFC2X3', *args, **kwargs) + + +def IfcFlowControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowControllerType', 'IFC2X3', *args, **kwargs) + + +def IfcFlowFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFitting', 'IFC2X3', *args, **kwargs) + + +def IfcFlowFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFittingType', 'IFC2X3', *args, **kwargs) + + +def IfcFlowInstrumentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrumentType', 'IFC2X3', *args, **kwargs) + + +def IfcFlowMeterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeterType', 'IFC2X3', *args, **kwargs) + + +def IfcFlowMovingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDevice', 'IFC2X3', *args, **kwargs) + + +def IfcFlowMovingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDeviceType', 'IFC2X3', *args, **kwargs) + + +def IfcFlowSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegment', 'IFC2X3', *args, **kwargs) + + +def IfcFlowSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegmentType', 'IFC2X3', *args, **kwargs) + + +def IfcFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDevice', 'IFC2X3', *args, **kwargs) + + +def IfcFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDeviceType', 'IFC2X3', *args, **kwargs) + + +def IfcFlowTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminal', 'IFC2X3', *args, **kwargs) + + +def IfcFlowTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminalType', 'IFC2X3', *args, **kwargs) + + +def IfcFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDevice', 'IFC2X3', *args, **kwargs) + + +def IfcFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDeviceType', 'IFC2X3', *args, **kwargs) + + +def IfcFluidFlowProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcFluidFlowProperties', 'IFC2X3', *args, **kwargs) + + +def IfcFooting(*args, **kwargs): return ifcopenshell.create_entity('IfcFooting', 'IFC2X3', *args, **kwargs) + + +def IfcFuelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcFuelProperties', 'IFC2X3', *args, **kwargs) + + +def IfcFurnishingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElement', 'IFC2X3', *args, **kwargs) + + +def IfcFurnishingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElementType', 'IFC2X3', *args, **kwargs) + + +def IfcFurnitureStandard(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnitureStandard', 'IFC2X3', *args, **kwargs) + + +def IfcFurnitureType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnitureType', 'IFC2X3', *args, **kwargs) + + +def IfcGasTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcGasTerminalType', 'IFC2X3', *args, **kwargs) + + +def IfcGeneralMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcGeneralMaterialProperties', 'IFC2X3', *args, **kwargs) + + +def IfcGeneralProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcGeneralProfileProperties', 'IFC2X3', *args, **kwargs) + + +def IfcGeometricCurveSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricCurveSet', 'IFC2X3', *args, **kwargs) + + +def IfcGeometricRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationContext', 'IFC2X3', *args, **kwargs) + + +def IfcGeometricRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationItem', 'IFC2X3', *args, **kwargs) + + +def IfcGeometricRepresentationSubContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationSubContext', 'IFC2X3', *args, **kwargs) + + +def IfcGeometricSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricSet', 'IFC2X3', *args, **kwargs) + + +def IfcGrid(*args, **kwargs): return ifcopenshell.create_entity('IfcGrid', 'IFC2X3', *args, **kwargs) + + +def IfcGridAxis(*args, **kwargs): return ifcopenshell.create_entity('IfcGridAxis', 'IFC2X3', *args, **kwargs) + + +def IfcGridPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcGridPlacement', 'IFC2X3', *args, **kwargs) + + +def IfcGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcGroup', 'IFC2X3', *args, **kwargs) + + +def IfcHalfSpaceSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcHalfSpaceSolid', 'IFC2X3', *args, **kwargs) + + +def IfcHeatExchangerType(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchangerType', 'IFC2X3', *args, **kwargs) + + +def IfcHumidifierType(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifierType', 'IFC2X3', *args, **kwargs) + + +def IfcHygroscopicMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcHygroscopicMaterialProperties', 'IFC2X3', *args, **kwargs) + + +def IfcIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcIShapeProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcImageTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcImageTexture', 'IFC2X3', *args, **kwargs) + + +def IfcInventory(*args, **kwargs): return ifcopenshell.create_entity('IfcInventory', 'IFC2X3', *args, **kwargs) + + +def IfcIrregularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeries', 'IFC2X3', *args, **kwargs) + + +def IfcIrregularTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeriesValue', 'IFC2X3', *args, **kwargs) + + +def IfcJunctionBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBoxType', 'IFC2X3', *args, **kwargs) + + +def IfcLShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcLShapeProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcLaborResource(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResource', 'IFC2X3', *args, **kwargs) + + +def IfcLampType(*args, **kwargs): return ifcopenshell.create_entity('IfcLampType', 'IFC2X3', *args, **kwargs) + + +def IfcLibraryInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryInformation', 'IFC2X3', *args, **kwargs) + + +def IfcLibraryReference(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryReference', 'IFC2X3', *args, **kwargs) + + +def IfcLightDistributionData(*args, **kwargs): return ifcopenshell.create_entity('IfcLightDistributionData', 'IFC2X3', *args, **kwargs) + + +def IfcLightFixtureType(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixtureType', 'IFC2X3', *args, **kwargs) + + +def IfcLightIntensityDistribution(*args, **kwargs): return ifcopenshell.create_entity('IfcLightIntensityDistribution', 'IFC2X3', *args, **kwargs) + + +def IfcLightSource(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSource', 'IFC2X3', *args, **kwargs) + + +def IfcLightSourceAmbient(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceAmbient', 'IFC2X3', *args, **kwargs) + + +def IfcLightSourceDirectional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceDirectional', 'IFC2X3', *args, **kwargs) + + +def IfcLightSourceGoniometric(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceGoniometric', 'IFC2X3', *args, **kwargs) + + +def IfcLightSourcePositional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourcePositional', 'IFC2X3', *args, **kwargs) + + +def IfcLightSourceSpot(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceSpot', 'IFC2X3', *args, **kwargs) + + +def IfcLine(*args, **kwargs): return ifcopenshell.create_entity('IfcLine', 'IFC2X3', *args, **kwargs) + + +def IfcLinearDimension(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearDimension', 'IFC2X3', *args, **kwargs) + + +def IfcLocalPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLocalPlacement', 'IFC2X3', *args, **kwargs) + + +def IfcLocalTime(*args, **kwargs): return ifcopenshell.create_entity('IfcLocalTime', 'IFC2X3', *args, **kwargs) + + +def IfcLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcLoop', 'IFC2X3', *args, **kwargs) + + +def IfcManifoldSolidBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcManifoldSolidBrep', 'IFC2X3', *args, **kwargs) + + +def IfcMappedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcMappedItem', 'IFC2X3', *args, **kwargs) + + +def IfcMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterial', 'IFC2X3', *args, **kwargs) + + +def IfcMaterialClassificationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialClassificationRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcMaterialDefinitionRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinitionRepresentation', 'IFC2X3', *args, **kwargs) + + +def IfcMaterialLayer(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayer', 'IFC2X3', *args, **kwargs) + + +def IfcMaterialLayerSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSet', 'IFC2X3', *args, **kwargs) + + +def IfcMaterialLayerSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSetUsage', 'IFC2X3', *args, **kwargs) + + +def IfcMaterialList(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialList', 'IFC2X3', *args, **kwargs) + + +def IfcMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProperties', 'IFC2X3', *args, **kwargs) + + +def IfcMeasureWithUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMeasureWithUnit', 'IFC2X3', *args, **kwargs) + + +def IfcMechanicalConcreteMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalConcreteMaterialProperties', 'IFC2X3', *args, **kwargs) + + +def IfcMechanicalFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastener', 'IFC2X3', *args, **kwargs) + + +def IfcMechanicalFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastenerType', 'IFC2X3', *args, **kwargs) + + +def IfcMechanicalMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalMaterialProperties', 'IFC2X3', *args, **kwargs) + + +def IfcMechanicalSteelMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalSteelMaterialProperties', 'IFC2X3', *args, **kwargs) + + +def IfcMember(*args, **kwargs): return ifcopenshell.create_entity('IfcMember', 'IFC2X3', *args, **kwargs) + + +def IfcMemberType(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberType', 'IFC2X3', *args, **kwargs) + + +def IfcMetric(*args, **kwargs): return ifcopenshell.create_entity('IfcMetric', 'IFC2X3', *args, **kwargs) + + +def IfcMonetaryUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMonetaryUnit', 'IFC2X3', *args, **kwargs) + + +def IfcMotorConnectionType(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnectionType', 'IFC2X3', *args, **kwargs) + + +def IfcMove(*args, **kwargs): return ifcopenshell.create_entity('IfcMove', 'IFC2X3', *args, **kwargs) + + +def IfcNamedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcNamedUnit', 'IFC2X3', *args, **kwargs) + + +def IfcObject(*args, **kwargs): return ifcopenshell.create_entity('IfcObject', 'IFC2X3', *args, **kwargs) + + +def IfcObjectDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectDefinition', 'IFC2X3', *args, **kwargs) + + +def IfcObjectPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectPlacement', 'IFC2X3', *args, **kwargs) + + +def IfcObjective(*args, **kwargs): return ifcopenshell.create_entity('IfcObjective', 'IFC2X3', *args, **kwargs) + + +def IfcOccupant(*args, **kwargs): return ifcopenshell.create_entity('IfcOccupant', 'IFC2X3', *args, **kwargs) + + +def IfcOffsetCurve2D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve2D', 'IFC2X3', *args, **kwargs) + + +def IfcOffsetCurve3D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve3D', 'IFC2X3', *args, **kwargs) + + +def IfcOneDirectionRepeatFactor(*args, **kwargs): return ifcopenshell.create_entity('IfcOneDirectionRepeatFactor', 'IFC2X3', *args, **kwargs) + + +def IfcOpenShell(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenShell', 'IFC2X3', *args, **kwargs) + + +def IfcOpeningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningElement', 'IFC2X3', *args, **kwargs) + + +def IfcOpticalMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcOpticalMaterialProperties', 'IFC2X3', *args, **kwargs) + + +def IfcOrderAction(*args, **kwargs): return ifcopenshell.create_entity('IfcOrderAction', 'IFC2X3', *args, **kwargs) + + +def IfcOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganization', 'IFC2X3', *args, **kwargs) + + +def IfcOrganizationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganizationRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcOrientedEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcOrientedEdge', 'IFC2X3', *args, **kwargs) + + +def IfcOutletType(*args, **kwargs): return ifcopenshell.create_entity('IfcOutletType', 'IFC2X3', *args, **kwargs) + + +def IfcOwnerHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcOwnerHistory', 'IFC2X3', *args, **kwargs) + + +def IfcParameterizedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcParameterizedProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcPath(*args, **kwargs): return ifcopenshell.create_entity('IfcPath', 'IFC2X3', *args, **kwargs) + + +def IfcPerformanceHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcPerformanceHistory', 'IFC2X3', *args, **kwargs) + + +def IfcPermeableCoveringProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPermeableCoveringProperties', 'IFC2X3', *args, **kwargs) + + +def IfcPermit(*args, **kwargs): return ifcopenshell.create_entity('IfcPermit', 'IFC2X3', *args, **kwargs) + + +def IfcPerson(*args, **kwargs): return ifcopenshell.create_entity('IfcPerson', 'IFC2X3', *args, **kwargs) + + +def IfcPersonAndOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcPersonAndOrganization', 'IFC2X3', *args, **kwargs) + + +def IfcPhysicalComplexQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalComplexQuantity', 'IFC2X3', *args, **kwargs) + + +def IfcPhysicalQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalQuantity', 'IFC2X3', *args, **kwargs) + + +def IfcPhysicalSimpleQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalSimpleQuantity', 'IFC2X3', *args, **kwargs) + + +def IfcPile(*args, **kwargs): return ifcopenshell.create_entity('IfcPile', 'IFC2X3', *args, **kwargs) + + +def IfcPipeFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFittingType', 'IFC2X3', *args, **kwargs) + + +def IfcPipeSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegmentType', 'IFC2X3', *args, **kwargs) + + +def IfcPixelTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcPixelTexture', 'IFC2X3', *args, **kwargs) + + +def IfcPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcPlacement', 'IFC2X3', *args, **kwargs) + + +def IfcPlanarBox(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarBox', 'IFC2X3', *args, **kwargs) + + +def IfcPlanarExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarExtent', 'IFC2X3', *args, **kwargs) + + +def IfcPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcPlane', 'IFC2X3', *args, **kwargs) + + +def IfcPlate(*args, **kwargs): return ifcopenshell.create_entity('IfcPlate', 'IFC2X3', *args, **kwargs) + + +def IfcPlateType(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateType', 'IFC2X3', *args, **kwargs) + + +def IfcPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcPoint', 'IFC2X3', *args, **kwargs) + + +def IfcPointOnCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnCurve', 'IFC2X3', *args, **kwargs) + + +def IfcPointOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnSurface', 'IFC2X3', *args, **kwargs) + + +def IfcPolyLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyLoop', 'IFC2X3', *args, **kwargs) + + +def IfcPolygonalBoundedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalBoundedHalfSpace', 'IFC2X3', *args, **kwargs) + + +def IfcPolyline(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyline', 'IFC2X3', *args, **kwargs) + + +def IfcPort(*args, **kwargs): return ifcopenshell.create_entity('IfcPort', 'IFC2X3', *args, **kwargs) + + +def IfcPostalAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcPostalAddress', 'IFC2X3', *args, **kwargs) + + +def IfcPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedColour', 'IFC2X3', *args, **kwargs) + + +def IfcPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedCurveFont', 'IFC2X3', *args, **kwargs) + + +def IfcPreDefinedDimensionSymbol(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedDimensionSymbol', 'IFC2X3', *args, **kwargs) + + +def IfcPreDefinedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedItem', 'IFC2X3', *args, **kwargs) + + +def IfcPreDefinedPointMarkerSymbol(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedPointMarkerSymbol', 'IFC2X3', *args, **kwargs) + + +def IfcPreDefinedSymbol(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedSymbol', 'IFC2X3', *args, **kwargs) + + +def IfcPreDefinedTerminatorSymbol(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedTerminatorSymbol', 'IFC2X3', *args, **kwargs) + + +def IfcPreDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedTextFont', 'IFC2X3', *args, **kwargs) + + +def IfcPresentationLayerAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerAssignment', 'IFC2X3', *args, **kwargs) + + +def IfcPresentationLayerWithStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerWithStyle', 'IFC2X3', *args, **kwargs) + + +def IfcPresentationStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyle', 'IFC2X3', *args, **kwargs) + + +def IfcPresentationStyleAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyleAssignment', 'IFC2X3', *args, **kwargs) + + +def IfcProcedure(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedure', 'IFC2X3', *args, **kwargs) + + +def IfcProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcProcess', 'IFC2X3', *args, **kwargs) + + +def IfcProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcProduct', 'IFC2X3', *args, **kwargs) + + +def IfcProductDefinitionShape(*args, **kwargs): return ifcopenshell.create_entity('IfcProductDefinitionShape', 'IFC2X3', *args, **kwargs) + + +def IfcProductRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcProductRepresentation', 'IFC2X3', *args, **kwargs) + + +def IfcProductsOfCombustionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcProductsOfCombustionProperties', 'IFC2X3', *args, **kwargs) + + +def IfcProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileProperties', 'IFC2X3', *args, **kwargs) + + +def IfcProject(*args, **kwargs): return ifcopenshell.create_entity('IfcProject', 'IFC2X3', *args, **kwargs) + + +def IfcProjectOrder(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectOrder', 'IFC2X3', *args, **kwargs) + + +def IfcProjectOrderRecord(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectOrderRecord', 'IFC2X3', *args, **kwargs) + + +def IfcProjectionCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectionCurve', 'IFC2X3', *args, **kwargs) + + +def IfcProjectionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectionElement', 'IFC2X3', *args, **kwargs) + + +def IfcProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcProperty', 'IFC2X3', *args, **kwargs) + + +def IfcPropertyBoundedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyBoundedValue', 'IFC2X3', *args, **kwargs) + + +def IfcPropertyConstraintRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyConstraintRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcPropertyDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDefinition', 'IFC2X3', *args, **kwargs) + + +def IfcPropertyDependencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDependencyRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcPropertyEnumeratedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeratedValue', 'IFC2X3', *args, **kwargs) + + +def IfcPropertyEnumeration(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeration', 'IFC2X3', *args, **kwargs) + + +def IfcPropertyListValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyListValue', 'IFC2X3', *args, **kwargs) + + +def IfcPropertyReferenceValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyReferenceValue', 'IFC2X3', *args, **kwargs) + + +def IfcPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySet', 'IFC2X3', *args, **kwargs) + + +def IfcPropertySetDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetDefinition', 'IFC2X3', *args, **kwargs) + + +def IfcPropertySingleValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySingleValue', 'IFC2X3', *args, **kwargs) + + +def IfcPropertyTableValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTableValue', 'IFC2X3', *args, **kwargs) + + +def IfcProtectiveDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceType', 'IFC2X3', *args, **kwargs) + + +def IfcProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcProxy', 'IFC2X3', *args, **kwargs) + + +def IfcPumpType(*args, **kwargs): return ifcopenshell.create_entity('IfcPumpType', 'IFC2X3', *args, **kwargs) + + +def IfcQuantityArea(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityArea', 'IFC2X3', *args, **kwargs) + + +def IfcQuantityCount(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityCount', 'IFC2X3', *args, **kwargs) + + +def IfcQuantityLength(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityLength', 'IFC2X3', *args, **kwargs) + + +def IfcQuantityTime(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityTime', 'IFC2X3', *args, **kwargs) + + +def IfcQuantityVolume(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityVolume', 'IFC2X3', *args, **kwargs) + + +def IfcQuantityWeight(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityWeight', 'IFC2X3', *args, **kwargs) + + +def IfcRadiusDimension(*args, **kwargs): return ifcopenshell.create_entity('IfcRadiusDimension', 'IFC2X3', *args, **kwargs) + + +def IfcRailing(*args, **kwargs): return ifcopenshell.create_entity('IfcRailing', 'IFC2X3', *args, **kwargs) + + +def IfcRailingType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailingType', 'IFC2X3', *args, **kwargs) + + +def IfcRamp(*args, **kwargs): return ifcopenshell.create_entity('IfcRamp', 'IFC2X3', *args, **kwargs) + + +def IfcRampFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlight', 'IFC2X3', *args, **kwargs) + + +def IfcRampFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlightType', 'IFC2X3', *args, **kwargs) + + +def IfcRationalBezierCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBezierCurve', 'IFC2X3', *args, **kwargs) + + +def IfcRectangleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleHollowProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcRectangularPyramid(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularPyramid', 'IFC2X3', *args, **kwargs) + + +def IfcRectangularTrimmedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularTrimmedSurface', 'IFC2X3', *args, **kwargs) + + +def IfcReferencesValueDocument(*args, **kwargs): return ifcopenshell.create_entity('IfcReferencesValueDocument', 'IFC2X3', *args, **kwargs) + + +def IfcRegularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcRegularTimeSeries', 'IFC2X3', *args, **kwargs) + + +def IfcReinforcementBarProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementBarProperties', 'IFC2X3', *args, **kwargs) + + +def IfcReinforcementDefinitionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementDefinitionProperties', 'IFC2X3', *args, **kwargs) + + +def IfcReinforcingBar(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBar', 'IFC2X3', *args, **kwargs) + + +def IfcReinforcingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElement', 'IFC2X3', *args, **kwargs) + + +def IfcReinforcingMesh(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMesh', 'IFC2X3', *args, **kwargs) + + +def IfcRelAggregates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAggregates', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssigns(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssigns', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssignsTasks(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsTasks', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssignsToActor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToActor', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssignsToControl(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToControl', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssignsToGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroup', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssignsToProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProcess', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssignsToProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProduct', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssignsToProjectOrder(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProjectOrder', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssignsToResource(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToResource', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssociates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociates', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssociatesAppliedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesAppliedValue', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssociatesApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesApproval', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssociatesClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesClassification', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssociatesConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesConstraint', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssociatesDocument(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesDocument', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssociatesLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesLibrary', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssociatesMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesMaterial', 'IFC2X3', *args, **kwargs) + + +def IfcRelAssociatesProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesProfileProperties', 'IFC2X3', *args, **kwargs) + + +def IfcRelConnects(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnects', 'IFC2X3', *args, **kwargs) + + +def IfcRelConnectsElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsElements', 'IFC2X3', *args, **kwargs) + + +def IfcRelConnectsPathElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPathElements', 'IFC2X3', *args, **kwargs) + + +def IfcRelConnectsPortToElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPortToElement', 'IFC2X3', *args, **kwargs) + + +def IfcRelConnectsPorts(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPorts', 'IFC2X3', *args, **kwargs) + + +def IfcRelConnectsStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralActivity', 'IFC2X3', *args, **kwargs) + + +def IfcRelConnectsStructuralElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralElement', 'IFC2X3', *args, **kwargs) + + +def IfcRelConnectsStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralMember', 'IFC2X3', *args, **kwargs) + + +def IfcRelConnectsWithEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithEccentricity', 'IFC2X3', *args, **kwargs) + + +def IfcRelConnectsWithRealizingElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithRealizingElements', 'IFC2X3', *args, **kwargs) + + +def IfcRelContainedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelContainedInSpatialStructure', 'IFC2X3', *args, **kwargs) + + +def IfcRelCoversBldgElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversBldgElements', 'IFC2X3', *args, **kwargs) + + +def IfcRelCoversSpaces(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversSpaces', 'IFC2X3', *args, **kwargs) + + +def IfcRelDecomposes(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDecomposes', 'IFC2X3', *args, **kwargs) + + +def IfcRelDefines(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefines', 'IFC2X3', *args, **kwargs) + + +def IfcRelDefinesByProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByProperties', 'IFC2X3', *args, **kwargs) + + +def IfcRelDefinesByType(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByType', 'IFC2X3', *args, **kwargs) + + +def IfcRelFillsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFillsElement', 'IFC2X3', *args, **kwargs) + + +def IfcRelFlowControlElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFlowControlElements', 'IFC2X3', *args, **kwargs) + + +def IfcRelInteractionRequirements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelInteractionRequirements', 'IFC2X3', *args, **kwargs) + + +def IfcRelNests(*args, **kwargs): return ifcopenshell.create_entity('IfcRelNests', 'IFC2X3', *args, **kwargs) + + +def IfcRelOccupiesSpaces(*args, **kwargs): return ifcopenshell.create_entity('IfcRelOccupiesSpaces', 'IFC2X3', *args, **kwargs) + + +def IfcRelOverridesProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcRelOverridesProperties', 'IFC2X3', *args, **kwargs) + + +def IfcRelProjectsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelProjectsElement', 'IFC2X3', *args, **kwargs) + + +def IfcRelReferencedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelReferencedInSpatialStructure', 'IFC2X3', *args, **kwargs) + + +def IfcRelSchedulesCostItems(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSchedulesCostItems', 'IFC2X3', *args, **kwargs) + + +def IfcRelSequence(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSequence', 'IFC2X3', *args, **kwargs) + + +def IfcRelServicesBuildings(*args, **kwargs): return ifcopenshell.create_entity('IfcRelServicesBuildings', 'IFC2X3', *args, **kwargs) + + +def IfcRelSpaceBoundary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary', 'IFC2X3', *args, **kwargs) + + +def IfcRelVoidsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelVoidsElement', 'IFC2X3', *args, **kwargs) + + +def IfcRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcRelaxation(*args, **kwargs): return ifcopenshell.create_entity('IfcRelaxation', 'IFC2X3', *args, **kwargs) + + +def IfcRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentation', 'IFC2X3', *args, **kwargs) + + +def IfcRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationContext', 'IFC2X3', *args, **kwargs) + + +def IfcRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationItem', 'IFC2X3', *args, **kwargs) + + +def IfcRepresentationMap(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationMap', 'IFC2X3', *args, **kwargs) + + +def IfcResource(*args, **kwargs): return ifcopenshell.create_entity('IfcResource', 'IFC2X3', *args, **kwargs) + + +def IfcRevolvedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolid', 'IFC2X3', *args, **kwargs) + + +def IfcRibPlateProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcRibPlateProfileProperties', 'IFC2X3', *args, **kwargs) + + +def IfcRightCircularCone(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCone', 'IFC2X3', *args, **kwargs) + + +def IfcRightCircularCylinder(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCylinder', 'IFC2X3', *args, **kwargs) + + +def IfcRoof(*args, **kwargs): return ifcopenshell.create_entity('IfcRoof', 'IFC2X3', *args, **kwargs) + + +def IfcRoot(*args, **kwargs): return ifcopenshell.create_entity('IfcRoot', 'IFC2X3', *args, **kwargs) + + +def IfcRoundedEdgeFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcRoundedEdgeFeature', 'IFC2X3', *args, **kwargs) + + +def IfcRoundedRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRoundedRectangleProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcSIUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcSIUnit', 'IFC2X3', *args, **kwargs) + + +def IfcSanitaryTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminalType', 'IFC2X3', *args, **kwargs) + + +def IfcScheduleTimeControl(*args, **kwargs): return ifcopenshell.create_entity('IfcScheduleTimeControl', 'IFC2X3', *args, **kwargs) + + +def IfcSectionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionProperties', 'IFC2X3', *args, **kwargs) + + +def IfcSectionReinforcementProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionReinforcementProperties', 'IFC2X3', *args, **kwargs) + + +def IfcSectionedSpine(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSpine', 'IFC2X3', *args, **kwargs) + + +def IfcSensorType(*args, **kwargs): return ifcopenshell.create_entity('IfcSensorType', 'IFC2X3', *args, **kwargs) + + +def IfcServiceLife(*args, **kwargs): return ifcopenshell.create_entity('IfcServiceLife', 'IFC2X3', *args, **kwargs) + + +def IfcServiceLifeFactor(*args, **kwargs): return ifcopenshell.create_entity('IfcServiceLifeFactor', 'IFC2X3', *args, **kwargs) + + +def IfcShapeAspect(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeAspect', 'IFC2X3', *args, **kwargs) + + +def IfcShapeModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeModel', 'IFC2X3', *args, **kwargs) + + +def IfcShapeRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeRepresentation', 'IFC2X3', *args, **kwargs) + + +def IfcShellBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShellBasedSurfaceModel', 'IFC2X3', *args, **kwargs) + + +def IfcSimpleProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcSimpleProperty', 'IFC2X3', *args, **kwargs) + + +def IfcSite(*args, **kwargs): return ifcopenshell.create_entity('IfcSite', 'IFC2X3', *args, **kwargs) + + +def IfcSlab(*args, **kwargs): return ifcopenshell.create_entity('IfcSlab', 'IFC2X3', *args, **kwargs) + + +def IfcSlabType(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabType', 'IFC2X3', *args, **kwargs) + + +def IfcSlippageConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcSlippageConnectionCondition', 'IFC2X3', *args, **kwargs) + + +def IfcSolidModel(*args, **kwargs): return ifcopenshell.create_entity('IfcSolidModel', 'IFC2X3', *args, **kwargs) + + +def IfcSoundProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSoundProperties', 'IFC2X3', *args, **kwargs) + + +def IfcSoundValue(*args, **kwargs): return ifcopenshell.create_entity('IfcSoundValue', 'IFC2X3', *args, **kwargs) + + +def IfcSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcSpace', 'IFC2X3', *args, **kwargs) + + +def IfcSpaceHeaterType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeaterType', 'IFC2X3', *args, **kwargs) + + +def IfcSpaceProgram(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceProgram', 'IFC2X3', *args, **kwargs) + + +def IfcSpaceThermalLoadProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceThermalLoadProperties', 'IFC2X3', *args, **kwargs) + + +def IfcSpaceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceType', 'IFC2X3', *args, **kwargs) + + +def IfcSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElement', 'IFC2X3', *args, **kwargs) + + +def IfcSpatialStructureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElementType', 'IFC2X3', *args, **kwargs) + + +def IfcSphere(*args, **kwargs): return ifcopenshell.create_entity('IfcSphere', 'IFC2X3', *args, **kwargs) + + +def IfcStackTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminalType', 'IFC2X3', *args, **kwargs) + + +def IfcStair(*args, **kwargs): return ifcopenshell.create_entity('IfcStair', 'IFC2X3', *args, **kwargs) + + +def IfcStairFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlight', 'IFC2X3', *args, **kwargs) + + +def IfcStairFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlightType', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAction', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralActivity', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralAnalysisModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAnalysisModel', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnection', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnectionCondition', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralCurveConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveConnection', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralCurveMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMember', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralCurveMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMemberVarying', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralItem', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralLinearAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLinearAction', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralLinearActionVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLinearActionVarying', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralLoad(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoad', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralLoadGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadGroup', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralLoadLinearForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadLinearForce', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralLoadPlanarForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadPlanarForce', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacement(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacement', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacementDistortion(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacementDistortion', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralLoadSingleForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForce', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralLoadSingleForceWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForceWarping', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralLoadStatic(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadStatic', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralLoadTemperature(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadTemperature', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralMember', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralPlanarAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPlanarAction', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralPlanarActionVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPlanarActionVarying', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralPointAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointAction', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralPointConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointConnection', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralPointReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointReaction', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralProfileProperties', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralReaction', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralResultGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralResultGroup', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralSteelProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSteelProfileProperties', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralSurfaceConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceConnection', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralSurfaceMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMember', 'IFC2X3', *args, **kwargs) + + +def IfcStructuralSurfaceMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMemberVarying', 'IFC2X3', *args, **kwargs) + + +def IfcStructuredDimensionCallout(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuredDimensionCallout', 'IFC2X3', *args, **kwargs) + + +def IfcStyleModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStyleModel', 'IFC2X3', *args, **kwargs) + + +def IfcStyledItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledItem', 'IFC2X3', *args, **kwargs) + + +def IfcStyledRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledRepresentation', 'IFC2X3', *args, **kwargs) + + +def IfcSubContractResource(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResource', 'IFC2X3', *args, **kwargs) + + +def IfcSubedge(*args, **kwargs): return ifcopenshell.create_entity('IfcSubedge', 'IFC2X3', *args, **kwargs) + + +def IfcSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSurface', 'IFC2X3', *args, **kwargs) + + +def IfcSurfaceCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurveSweptAreaSolid', 'IFC2X3', *args, **kwargs) + + +def IfcSurfaceOfLinearExtrusion(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfLinearExtrusion', 'IFC2X3', *args, **kwargs) + + +def IfcSurfaceOfRevolution(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfRevolution', 'IFC2X3', *args, **kwargs) + + +def IfcSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyle', 'IFC2X3', *args, **kwargs) + + +def IfcSurfaceStyleLighting(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleLighting', 'IFC2X3', *args, **kwargs) + + +def IfcSurfaceStyleRefraction(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRefraction', 'IFC2X3', *args, **kwargs) + + +def IfcSurfaceStyleRendering(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRendering', 'IFC2X3', *args, **kwargs) + + +def IfcSurfaceStyleShading(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleShading', 'IFC2X3', *args, **kwargs) + + +def IfcSurfaceStyleWithTextures(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleWithTextures', 'IFC2X3', *args, **kwargs) + + +def IfcSurfaceTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceTexture', 'IFC2X3', *args, **kwargs) + + +def IfcSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptAreaSolid', 'IFC2X3', *args, **kwargs) + + +def IfcSweptDiskSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolid', 'IFC2X3', *args, **kwargs) + + +def IfcSweptSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptSurface', 'IFC2X3', *args, **kwargs) + + +def IfcSwitchingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDeviceType', 'IFC2X3', *args, **kwargs) + + +def IfcSymbolStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcSymbolStyle', 'IFC2X3', *args, **kwargs) + + +def IfcSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcSystem', 'IFC2X3', *args, **kwargs) + + +def IfcSystemFurnitureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElementType', 'IFC2X3', *args, **kwargs) + + +def IfcTShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTShapeProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcTable(*args, **kwargs): return ifcopenshell.create_entity('IfcTable', 'IFC2X3', *args, **kwargs) + + +def IfcTableRow(*args, **kwargs): return ifcopenshell.create_entity('IfcTableRow', 'IFC2X3', *args, **kwargs) + + +def IfcTankType(*args, **kwargs): return ifcopenshell.create_entity('IfcTankType', 'IFC2X3', *args, **kwargs) + + +def IfcTask(*args, **kwargs): return ifcopenshell.create_entity('IfcTask', 'IFC2X3', *args, **kwargs) + + +def IfcTelecomAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcTelecomAddress', 'IFC2X3', *args, **kwargs) + + +def IfcTendon(*args, **kwargs): return ifcopenshell.create_entity('IfcTendon', 'IFC2X3', *args, **kwargs) + + +def IfcTendonAnchor(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchor', 'IFC2X3', *args, **kwargs) + + +def IfcTerminatorSymbol(*args, **kwargs): return ifcopenshell.create_entity('IfcTerminatorSymbol', 'IFC2X3', *args, **kwargs) + + +def IfcTextLiteral(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteral', 'IFC2X3', *args, **kwargs) + + +def IfcTextLiteralWithExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteralWithExtent', 'IFC2X3', *args, **kwargs) + + +def IfcTextStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyle', 'IFC2X3', *args, **kwargs) + + +def IfcTextStyleFontModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleFontModel', 'IFC2X3', *args, **kwargs) + + +def IfcTextStyleForDefinedFont(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleForDefinedFont', 'IFC2X3', *args, **kwargs) + + +def IfcTextStyleTextModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleTextModel', 'IFC2X3', *args, **kwargs) + + +def IfcTextStyleWithBoxCharacteristics(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleWithBoxCharacteristics', 'IFC2X3', *args, **kwargs) + + +def IfcTextureCoordinate(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinate', 'IFC2X3', *args, **kwargs) + + +def IfcTextureCoordinateGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateGenerator', 'IFC2X3', *args, **kwargs) + + +def IfcTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureMap', 'IFC2X3', *args, **kwargs) + + +def IfcTextureVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertex', 'IFC2X3', *args, **kwargs) + + +def IfcThermalMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcThermalMaterialProperties', 'IFC2X3', *args, **kwargs) + + +def IfcTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeries', 'IFC2X3', *args, **kwargs) + + +def IfcTimeSeriesReferenceRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeriesReferenceRelationship', 'IFC2X3', *args, **kwargs) + + +def IfcTimeSeriesSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeriesSchedule', 'IFC2X3', *args, **kwargs) + + +def IfcTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeriesValue', 'IFC2X3', *args, **kwargs) + + +def IfcTopologicalRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologicalRepresentationItem', 'IFC2X3', *args, **kwargs) + + +def IfcTopologyRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologyRepresentation', 'IFC2X3', *args, **kwargs) + + +def IfcTransformerType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformerType', 'IFC2X3', *args, **kwargs) + + +def IfcTransportElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElement', 'IFC2X3', *args, **kwargs) + + +def IfcTransportElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElementType', 'IFC2X3', *args, **kwargs) + + +def IfcTrapeziumProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTrapeziumProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcTrimmedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcTrimmedCurve', 'IFC2X3', *args, **kwargs) + + +def IfcTubeBundleType(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundleType', 'IFC2X3', *args, **kwargs) + + +def IfcTwoDirectionRepeatFactor(*args, **kwargs): return ifcopenshell.create_entity('IfcTwoDirectionRepeatFactor', 'IFC2X3', *args, **kwargs) + + +def IfcTypeObject(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeObject', 'IFC2X3', *args, **kwargs) + + +def IfcTypeProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProduct', 'IFC2X3', *args, **kwargs) + + +def IfcUShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcUShapeProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcUnitAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitAssignment', 'IFC2X3', *args, **kwargs) + + +def IfcUnitaryEquipmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipmentType', 'IFC2X3', *args, **kwargs) + + +def IfcValveType(*args, **kwargs): return ifcopenshell.create_entity('IfcValveType', 'IFC2X3', *args, **kwargs) + + +def IfcVector(*args, **kwargs): return ifcopenshell.create_entity('IfcVector', 'IFC2X3', *args, **kwargs) + + +def IfcVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcVertex', 'IFC2X3', *args, **kwargs) + + +def IfcVertexBasedTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexBasedTextureMap', 'IFC2X3', *args, **kwargs) + + +def IfcVertexLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexLoop', 'IFC2X3', *args, **kwargs) + + +def IfcVertexPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexPoint', 'IFC2X3', *args, **kwargs) + + +def IfcVibrationIsolatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolatorType', 'IFC2X3', *args, **kwargs) + + +def IfcVirtualElement(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualElement', 'IFC2X3', *args, **kwargs) + + +def IfcVirtualGridIntersection(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualGridIntersection', 'IFC2X3', *args, **kwargs) + + +def IfcWall(*args, **kwargs): return ifcopenshell.create_entity('IfcWall', 'IFC2X3', *args, **kwargs) + + +def IfcWallStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallStandardCase', 'IFC2X3', *args, **kwargs) + + +def IfcWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcWallType', 'IFC2X3', *args, **kwargs) + + +def IfcWasteTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminalType', 'IFC2X3', *args, **kwargs) + + +def IfcWaterProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWaterProperties', 'IFC2X3', *args, **kwargs) + + +def IfcWindow(*args, **kwargs): return ifcopenshell.create_entity('IfcWindow', 'IFC2X3', *args, **kwargs) + + +def IfcWindowLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowLiningProperties', 'IFC2X3', *args, **kwargs) + + +def IfcWindowPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowPanelProperties', 'IFC2X3', *args, **kwargs) + + +def IfcWindowStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowStyle', 'IFC2X3', *args, **kwargs) + + +def IfcWorkControl(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkControl', 'IFC2X3', *args, **kwargs) + + +def IfcWorkPlan(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkPlan', 'IFC2X3', *args, **kwargs) + + +def IfcWorkSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkSchedule', 'IFC2X3', *args, **kwargs) + + +def IfcZShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcZShapeProfileDef', 'IFC2X3', *args, **kwargs) + + +def IfcZone(*args, **kwargs): return ifcopenshell.create_entity('IfcZone', 'IFC2X3', *args, **kwargs) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcBoxAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcBoxAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['top-left','top-middle','top-right','middle-left','center','middle-right','bottom-left','bottom-middle','bottom-right'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCompoundPlaneAngleMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert -360 <= self[1 - 1] < 360 + + + + +class IfcCompoundPlaneAngleMeasure_WR2: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + + + assert -60 <= self[2 - 1] < 60 + + + + +class IfcCompoundPlaneAngleMeasure_WR3: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + + + assert -60 <= self[3 - 1] < 60 + + + + +class IfcCompoundPlaneAngleMeasure_WR4: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "WR4" + + @staticmethod + def __call__(self): + + + assert (((self[1 - 1]) >= 0) and ((self[2 - 1]) >= 0) and ((self[3 - 1]) >= 0)) or (((self[1 - 1]) <= 0) and ((self[2 - 1]) <= 0) and ((self[3 - 1]) <= 0)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDaylightSavingHour_WR1: + SCOPE = "type" + TYPE_NAME = "IfcDaylightSavingHour" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0 <= self <= 2 + + + + + + + + + + + + + + + + + +class IfcDimensionCount_WR1: + SCOPE = "type" + TYPE_NAME = "IfcDimensionCount" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0 < self <= 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFontStyle_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontStyle" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','italic','oblique'] + + + + + +class IfcFontVariant_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontVariant" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps'] + + + + + +class IfcFontWeight_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontWeight" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps','100','200','300','400','500','600','700','800','900'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcHeatingValueMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcHeatingValueMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcHourInDay_WR1: + SCOPE = "type" + TYPE_NAME = "IfcHourInDay" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0 <= self < 24 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMinuteInHour_WR1: + SCOPE = "type" + TYPE_NAME = "IfcMinuteInHour" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0 <= self <= 59 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMonthInYearNumber_WR1: + SCOPE = "type" + TYPE_NAME = "IfcMonthInYearNumber" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 12 + + + + + + + + +class IfcNormalisedRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcNormalisedRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPHMeasure_WR21: + SCOPE = "type" + TYPE_NAME = "IfcPHMeasure" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 14.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPositiveLengthMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveLengthMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositivePlaneAngleMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositivePlaneAngleMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositiveRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcSecondInMinute_WR1: + SCOPE = "type" + TYPE_NAME = "IfcSecondInMinute" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0. <= self < 60. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcSpecularRoughness_WR1: + SCOPE = "type" + TYPE_NAME = "IfcSpecularRoughness" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTextAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['left','right','center','justify'] + + + + + +class IfcTextDecoration_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextDecoration" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['none','underline','overline','line-through','blink'] + + + + + + + + + + + + + + + + + +class IfcTextTransformation_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextTransformation" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['capitalize','uppercase','lowercase','none'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class Ifc2DCompositeCurve_WR1: + SCOPE = "entity" + TYPE_NAME = "Ifc2DCompositeCurve" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self.ClosedCurve + + + + +class Ifc2DCompositeCurve_WR2: + SCOPE = "entity" + TYPE_NAME = "Ifc2DCompositeCurve" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + + + assert self.Dim == 2 + + + + + + + + + + + +class IfcActorRole_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcActorRole" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + role = self.Role + + assert (role != IfcRoleEnum.USERDEFINED) or ((role == IfcRoleEnum.USERDEFINED) and exists(self.UserDefinedRole)) + + + + + + + + +class IfcAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + purpose = self.Purpose + + assert (not exists(purpose)) or ((purpose != IfcAddressTypeEnum.USERDEFINED) or ((purpose == IfcAddressTypeEnum.USERDEFINED) and exists(self.UserDefinedPurpose))) + + + + + +class IfcAirTerminalBoxType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBoxType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirTerminalType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirToAirHeatRecoveryType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecoveryType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcAnnotationCurveOccurrence_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcAnnotationCurveOccurrence" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Item)) or ('ifc2x3.ifccurve' in typeof(self.Item)) + + + + + + + + +class IfcAnnotationFillAreaOccurrence_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcAnnotationFillAreaOccurrence" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Item)) or ('ifc2x3.ifcannotationfillarea' in typeof(self.Item)) + + + + + + + + +class IfcAnnotationSurface_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcAnnotationSurface" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + item = self.Item + + assert (sizeof(['ifc2x3.ifcsurface','ifc2x3.ifcshellbasedsurfacemodel','ifc2x3.ifcfacebasedsurfacemodel','ifc2x3.ifcsolidmodel','ifc2x3.ifcbooleanresult','ifc2x3.ifccsgprimitive3d'] * typeof(item))) >= 1 + + + + + +class IfcAnnotationSurfaceOccurrence_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcAnnotationSurfaceOccurrence" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Item)) or ((sizeof(['ifc2x3.ifcsurface','ifc2x3.ifcfacebasedsurfacemodel','ifc2x3.ifcshellbasedsurfacemodel','ifc2x3.ifcsolidmodel'] * typeof(self.Item))) > 0) + + + + + +class IfcAnnotationSymbolOccurrence_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcAnnotationSymbolOccurrence" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Item)) or ('ifc2x3.ifcdefinedsymbol' in typeof(self.Item)) + + + + + +class IfcAnnotationTextOccurrence_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcAnnotationTextOccurrence" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Item)) or ('ifc2x3.ifctextliteral' in typeof(self.Item)) + + + + + + + + +class IfcAppliedValue_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAppliedValue" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + appliedvalue = self.AppliedValue + valueofcomponents = self.ValueOfComponents + + assert exists(appliedvalue) or exists(valueofcomponents) + + + + + + + + + + + + + + + + + + + + +class IfcArbitraryClosedProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert outercurve.Dim == 2 + + + + +class IfcArbitraryClosedProfileDef_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc2x3.ifcline' in typeof(outercurve) + + + + +class IfcArbitraryClosedProfileDef_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc2x3.ifcoffsetcurve2d' in typeof(outercurve) + + + + + +class IfcArbitraryOpenProfileDef_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert ('ifc2x3.ifccenterlineprofiledef' in typeof(self)) or (self.ProfileType == IfcProfileTypeEnum.CURVE) + + + + +class IfcArbitraryOpenProfileDef_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + curve = self.Curve + + assert curve.Dim == 2 + + + + + +class IfcArbitraryProfileDefWithVoids_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == area + + + + +class IfcArbitraryProfileDefWithVoids_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if temp.Dim != 2])) == 0 + + + + +class IfcArbitraryProfileDefWithVoids_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if 'ifc2x3.ifcline' in typeof(temp)])) == 0 + + + + + +class IfcAsset_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAsset" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.IsGroupedBy.RelatedObjects if not 'ifc2x3.ifcelement' in typeof(temp)])) == 0 + + + + + + + + +class IfcAxis1Placement_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis1Placement_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +def calc_IfcAxis1Placement_Z(self): + axis = self.Axis + return \ + nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + + + + +class IfcAxis2Placement2D_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 2) + + + + +class IfcAxis2Placement2D_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 2 + + + + +def calc_IfcAxis2Placement2D_P(self): + refdirection = self.RefDirection + return \ + IfcBuild2Axes(refdirection) + + + + +class IfcAxis2Placement3D_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis2Placement3D_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis2Placement3D_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 3) + + + + +class IfcAxis2Placement3D_WR4: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "WR4" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + +class IfcAxis2Placement3D_WR5: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "WR5" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert not exists(axis) ^ exists(refdirection) + + + + +def calc_IfcAxis2Placement3D_P(self): + axis = self.Axis + refdirection = self.RefDirection + return \ + IfcBuildAxes(axis,refdirection) + + + + +class IfcBSplineCurve_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurve" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + controlpointslist = self.ControlPointsList + + assert (sizeof([temp for temp in controlpointslist if temp.Dim != (controlpointslist[1 - 1].Dim)])) == 0 + + + + +def calc_IfcBSplineCurve_ControlPoints(self): + controlpointslist = self.ControlPointsList + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + return \ + IfcListToArray(controlpointslist,0,upperindexoncontrolpoints) + + + +def calc_IfcBSplineCurve_UpperIndexOnControlPoints(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + + + + + + + + + + + +class IfcBlobTexture_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert self.RasterFormat in ['bmp','jpg','gif','png'] + + + + + + + + +class IfcBoilerType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcBoilerType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBooleanClippingResult_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert ('ifc2x3.ifcsweptareasolid' in typeof(firstoperand)) or ('ifc2x3.ifcbooleanclippingresult' in typeof(firstoperand)) + + + + +class IfcBooleanClippingResult_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert 'ifc2x3.ifchalfspacesolid' in typeof(secondoperand) + + + + +class IfcBooleanClippingResult_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + operator = self.Operator + + assert operator == difference + + + + + +class IfcBooleanResult_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + secondoperand = self.SecondOperand + + assert firstoperand.Dim == secondoperand.Dim + + + + +def calc_IfcBooleanResult_Dim(self): + firstoperand = self.FirstOperand + return \ + firstoperand.Dim + + + + + + + + + + + + + + + + + + + + + + + + + +def calc_IfcBoundingBox_Dim(self): + + return \ + 3 + + + + +class IfcBoxedHalfSpace_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcBoxedHalfSpace" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert not 'ifc2x3.ifccurveboundedplane' in typeof(self.BaseSurface) + + + + + + + + + + + + + + + + + +class IfcBuildingElementProxy_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + + + + + + + + + + +class IfcCShapeProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + depth = self.Depth + girth = self.Girth + + assert girth < (depth / 2.) + + + + +class IfcCShapeProfileDef_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + internalfilletradius = self.InternalFilletRadius + + assert (not exists(internalfilletradius)) or ((internalfilletradius <= (width / 2.)) and (internalfilletradius <= (depth / 2.))) + + + + +class IfcCShapeProfileDef_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + + assert (wallthickness < (width / 2.)) and (wallthickness < (depth / 2.)) + + + + + +class IfcCableCarrierFittingType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFittingType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcCalendarDate_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcCalendarDate" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert IfcValidCalendarDate(self) + + + + + +class IfcCartesianPoint_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianPoint" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + coordinates = self.Coordinates + + assert hiindex(coordinates) >= 2 + + + + +def calc_IfcCartesianPoint_Dim(self): + coordinates = self.Coordinates + return \ + hiindex(coordinates) + + + + +class IfcCartesianTransformationOperator_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + scl = self.Scl + + assert scl > 0.0 + + + + +def calc_IfcCartesianTransformationOperator_Scl(self): + scale = self.Scale + return \ + nvl(scale,1.0) + + + +def calc_IfcCartesianTransformationOperator_Dim(self): + localorigin = self.LocalOrigin + return \ + localorigin.Dim + + + + +class IfcCartesianTransformationOperator2D_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self.Dim == 2 + + + + +class IfcCartesianTransformationOperator2D_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 2) + + + + +class IfcCartesianTransformationOperator2D_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 2) + + + + +def calc_IfcCartesianTransformationOperator2D_U(self): + + return \ + IfcBaseAxis(2,self.Axis1,self.Axis2,None) + + + + +class IfcCartesianTransformationOperator2DnonUniform_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2DnonUniform" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator2DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + + +class IfcCartesianTransformationOperator3D_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self.Dim == 3 + + + + +class IfcCartesianTransformationOperator3D_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_WR4: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "WR4" + + @staticmethod + def __call__(self): + axis3 = self.Axis3 + + assert (not exists(axis3)) or (axis3.Dim == 3) + + + + +def calc_IfcCartesianTransformationOperator3D_U(self): + axis3 = self.Axis3 + return \ + IfcBaseAxis(3,self.Axis1,self.Axis2,axis3) + + + + +class IfcCartesianTransformationOperator3DnonUniform_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +class IfcCartesianTransformationOperator3DnonUniform_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + scl3 = self.Scl3 + + assert scl3 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl3(self): + scale3 = self.Scale3 + return \ + nvl(scale3,self.Scl) + + + + + + + + + + +class IfcChillerType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcChillerType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcCircleHollowProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCircleHollowProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert wallthickness < self.Radius + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCoilType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCoilType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + +class IfcComplexProperty_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert (sizeof([temp for temp in hasproperties if self == temp])) == 0 + + + + +class IfcComplexProperty_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + +class IfcCompositeCurve_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + segments = self.Segments + closedcurve = self.ClosedCurve + + assert ((not closedcurve) and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 1)) or (closedcurve and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 0)) + + + + +class IfcCompositeCurve_WR42: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "WR42" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (sizeof([temp for temp in segments if temp.Dim != (segments[1 - 1].Dim)])) == 0 + + + + +def calc_IfcCompositeCurve_NSegments(self): + segments = self.Segments + return \ + sizeof(segments) + + + +def calc_IfcCompositeCurve_ClosedCurve(self): + segments = self.Segments + nsegments = self.NSegments + return \ + (segments[nsegments - 1].Transition) != discontinuous + + + + +class IfcCompositeCurveSegment_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveSegment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + parentcurve = self.ParentCurve + + assert 'ifc2x3.ifcboundedcurve' in typeof(parentcurve) + + + + +def calc_IfcCompositeCurveSegment_Dim(self): + parentcurve = self.ParentCurve + return \ + parentcurve.Dim + + + + +class IfcCompositeProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if temp.ProfileType != (profiles[1 - 1].ProfileType)])) == 0 + + + + +class IfcCompositeProfileDef_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if 'ifc2x3.ifccompositeprofiledef' in typeof(temp)])) == 0 + + + + + +class IfcCompressorType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCompressorType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCondenserType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCondenserType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcConditionCriterion_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcConditionCriterion" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcConstraint_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcConstraint" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + constraintgrade = self.ConstraintGrade + + assert (constraintgrade != IfcConstraintEnum.USERDEFINED) or ((constraintgrade == IfcConstraintEnum.USERDEFINED) and exists(self.UserDefinedGrade)) + + + + + +class IfcConstraintAggregationRelationship_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcConstraintAggregationRelationship" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + relatingconstraint = self.RelatingConstraint + relatedconstraints = self.RelatedConstraints + + assert (sizeof([temp for temp in relatedconstraints if temp == relatingconstraint])) == 0 + + + + + + + + +class IfcConstraintRelationship_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcConstraintRelationship" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + relatingconstraint = self.RelatingConstraint + relatedconstraints = self.RelatedConstraints + + assert (sizeof([temp for temp in relatedconstraints if temp == relatingconstraint])) == 0 + + + + + + + + +class IfcConstructionMaterialResource_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResource" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert sizeof(self.ResourceOf) <= 1 + + + + +class IfcConstructionMaterialResource_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResource" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + + + assert (not exists(lambda: self.ResourceOf[1 - 1])) or ((self.ResourceOf[1 - 1].RelatedObjectsType) == IfcObjectTypeEnum.PRODUCT) + + + + + +class IfcConstructionProductResource_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResource" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert sizeof(self.ResourceOf) <= 1 + + + + +class IfcConstructionProductResource_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResource" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + + + assert (not exists(lambda: self.ResourceOf[1 - 1])) or ((self.ResourceOf[1 - 1].RelatedObjectsType) == IfcObjectTypeEnum.PRODUCT) + + + + + + + + + + + + + + + + + + + + +class IfcCooledBeamType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeamType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCoolingTowerType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTowerType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + +class IfcCovering_WR61: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "WR61" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + + + + + + + +def calc_IfcCsgPrimitive3D_Dim(self): + + return \ + 3 + + + + + + + + + + + + + + + + +def calc_IfcCurve_Dim(self): + + return \ + IfcCurveDim(self) + + + + +def calc_IfcCurveBoundedPlane_Dim(self): + basissurface = self.BasisSurface + return \ + basissurface.Dim + + + + +class IfcCurveStyle_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + curvewidth = self.CurveWidth + + assert (not exists(curvewidth)) or ('ifc2x3.ifcpositivelengthmeasure' in typeof(curvewidth)) or (('ifc2x3.ifcdescriptivemeasure' in typeof(curvewidth)) and (curvewidth == 'bylayer')) + + + + + + + + + + + +class IfcCurveStyleFontPattern_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyleFontPattern" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + visiblesegmentlength = self.VisibleSegmentLength + + assert visiblesegmentlength >= 0. + + + + + +class IfcDamperType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDamperType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcDerivedProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + parentprofile = self.ParentProfile + + assert self.ProfileType == parentprofile.ProfileType + + + + + +class IfcDerivedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof(elements) > 1) or ((sizeof(elements) == 1) and ((elements[1 - 1].Exponent) != 1)) + + + + +class IfcDerivedUnit_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + unittype = self.UnitType + + assert (unittype != IfcDerivedUnitEnum.USERDEFINED) or ((unittype == IfcDerivedUnitEnum.USERDEFINED) and exists(self.UserDefinedType)) + + + + +def calc_IfcDerivedUnit_Dimensions(self): + elements = self.Elements + return \ + IfcDeriveDimensionalExponents(elements) + + + + + + + + + + +class IfcDimensionCalloutRelationship_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcDimensionCalloutRelationship" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert self.Name in ['primary','secondary'] + + + + +class IfcDimensionCalloutRelationship_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcDimensionCalloutRelationship" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + + + assert (sizeof(typeof(self.RelatingDraughtingCallout) * ['ifc2x3.ifcangulardimension','ifc2x3.ifcdiameterdimension','ifc2x3.ifclineardimension','ifc2x3.ifcradiusdimension'])) == 1 + + + + +class IfcDimensionCalloutRelationship_WR13: + SCOPE = "entity" + TYPE_NAME = "IfcDimensionCalloutRelationship" + RULE_NAME = "WR13" + + @staticmethod + def __call__(self): + + + assert not 'ifc2x3.ifcdimensioncurvedirectedcallout' in typeof(self.RelatedDraughtingCallout) + + + + + +class IfcDimensionCurve_WR51: + SCOPE = "entity" + TYPE_NAME = "IfcDimensionCurve" + RULE_NAME = "WR51" + + @staticmethod + def __call__(self): + + + assert sizeof(usedin(self,'ifc2x3.ifcdraughtingcallout.contents')) >= 1 + + + + +class IfcDimensionCurve_WR52: + SCOPE = "entity" + TYPE_NAME = "IfcDimensionCurve" + RULE_NAME = "WR52" + + @staticmethod + def __call__(self): + + + assert ((sizeof([dct1 for dct1 in usedin(self,'ifc2x3.' + 'ifcterminatorsymbol.annotatedcurve') if dct1.Role == IfcDimensionExtentUsage.ORIGIN])) <= 1) and ((sizeof([dct2 for dct2 in usedin(self,'ifc2x3.' + 'ifcterminatorsymbol.annotatedcurve') if dct2.Role == IfcDimensionExtentUsage.TARGET])) <= 1) + + + + +class IfcDimensionCurve_WR53: + SCOPE = "entity" + TYPE_NAME = "IfcDimensionCurve" + RULE_NAME = "WR53" + + @staticmethod + def __call__(self): + annotatedbysymbols = self.AnnotatedBySymbols + + assert (sizeof([dct for dct in annotatedbysymbols if not 'ifc2x3.ifcdimensioncurveterminator' in typeof(dct)])) == 0 + + + + + +class IfcDimensionCurveDirectedCallout_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcDimensionCurveDirectedCallout" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + + + assert (sizeof([dc for dc in self.Contents if 'ifc2x3.ifcdimensioncurve' in typeof(dc)])) == 1 + + + + +class IfcDimensionCurveDirectedCallout_WR42: + SCOPE = "entity" + TYPE_NAME = "IfcDimensionCurveDirectedCallout" + RULE_NAME = "WR42" + + @staticmethod + def __call__(self): + contents = self.Contents + + assert (sizeof([dc for dc in self.contents if 'ifc2x3.ifcprojectioncurve' in typeof(dc)])) <= 2 + + + + + +class IfcDimensionCurveTerminator_WR61: + SCOPE = "entity" + TYPE_NAME = "IfcDimensionCurveTerminator" + RULE_NAME = "WR61" + + @staticmethod + def __call__(self): + + + assert 'ifc2x3.ifcdimensioncurve' in typeof(self.AnnotatedCurve) + + + + + +class IfcDimensionPair_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcDimensionPair" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert self.Name in ['chained','parallel'] + + + + +class IfcDimensionPair_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcDimensionPair" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + + + assert (sizeof(typeof(self.RelatingDraughtingCallout) * ['ifc2x3.ifcangulardimension','ifc2x3.ifcdiameterdimension','ifc2x3.ifclineardimension','ifc2x3.ifcradiusdimension'])) == 1 + + + + +class IfcDimensionPair_WR13: + SCOPE = "entity" + TYPE_NAME = "IfcDimensionPair" + RULE_NAME = "WR13" + + @staticmethod + def __call__(self): + + + assert (sizeof(typeof(self.RelatedDraughtingCallout) * ['ifc2x3.ifcangulardimension','ifc2x3.ifcdiameterdimension','ifc2x3.ifclineardimension','ifc2x3.ifcradiusdimension'])) == 1 + + + + + + + + +def calc_IfcDirection_Dim(self): + directionratios = self.DirectionRatios + return \ + hiindex(directionratios) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDocumentElectronicFormat_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDocumentElectronicFormat" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + fileextension = self.FileExtension + mimecontenttype = self.MimeContentType + + assert exists(fileextension) or exists(mimecontenttype) + + + + + + + + + + + +class IfcDocumentReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDocumentReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + name = self.Name + referencetodocument = self.ReferenceToDocument + + assert exists(name) ^ (exists(lambda: referencetodocument[1 - 1])) + + + + + + + + +class IfcDoorLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not (not exists(liningdepth)) and exists(liningthickness) + + + + +class IfcDoorLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + thresholddepth = self.ThresholdDepth + thresholdthickness = self.ThresholdThickness + + assert not (not exists(thresholddepth)) and exists(thresholdthickness) + + + + +class IfcDoorLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + transomthickness = self.TransomThickness + transomoffset = self.TransomOffset + + assert (exists(transomoffset) and exists(transomthickness)) ^ ((not exists(transomoffset)) and (not exists(transomthickness))) + + + + +class IfcDoorLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + casingthickness = self.CasingThickness + casingdepth = self.CasingDepth + + assert (exists(casingdepth) and exists(casingthickness)) ^ ((not exists(casingdepth)) and (not exists(casingthickness))) + + + + +class IfcDoorLiningProperties_WR35: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR35" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and ('ifc2x3.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1]))) + + + + + +class IfcDoorPanelProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcDoorPanelProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and ('ifc2x3.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1]))) + + + + + + + + + + + + + + +class IfcDraughtingPreDefinedColour_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedColour" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert self.Name in ['black','red','green','blue','yellow','magenta','cyan','white','bylayer'] + + + + + +class IfcDraughtingPreDefinedCurveFont_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedCurveFont" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert self.Name in ['continuous','chain','chaindoubledash','dashed','dotted','bylayer'] + + + + + +class IfcDraughtingPreDefinedTextFont_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedTextFont" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert self.Name in ['iso3098-1fonta','iso3098-1fontb'] + + + + + +class IfcDuctFittingType_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFittingType" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSegmentType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegmentType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSilencerType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencerType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcEdgeLoop_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + edgelist = self.EdgeList + ne = self.Ne + + assert (edgelist[1 - 1].EdgeStart) == (edgelist[ne - 1].EdgeEnd) + + + + +class IfcEdgeLoop_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + + + assert IfcLoopHeadToTail(self) + + + + +def calc_IfcEdgeLoop_Ne(self): + edgelist = self.EdgeList + return \ + sizeof(edgelist) + + + + + + + +class IfcElectricDistributionPoint_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionPoint" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + distributionpointfunction = self.DistributionPointFunction + + assert (distributionpointfunction != IfcElectricDistributionPointFunctionEnum.USERDEFINED) or ((distributionpointfunction == IfcElectricDistributionPointFunctionEnum.USERDEFINED) and exists(self.UserDefinedFunction)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcElementAssembly_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + + + + + + + +def calc_IfcElementarySurface_Dim(self): + position = self.Position + return \ + position.Dim + + + + + + + + + + + + + + + + + + + +class IfcEnvironmentalImpactValue_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcEnvironmentalImpactValue" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + category = self.Category + + assert (category != IfcEnvironmentalImpactCategoryEnum.USERDEFINED) or ((category == IfcEnvironmentalImpactCategoryEnum.USERDEFINED) and exists(self.UserDefinedCategory)) + + + + + + + + + + + +class IfcEvaporativeCoolerType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCoolerType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporatorType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporatorType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcExternalReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcExternalReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + location = self.Location + itemreference = self.ItemReference + name = self.Name + + assert exists(itemreference) or exists(location) or exists(name) + + + + + + + + + + + + + + + + + +class IfcExtrudedAreaSolid_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolid" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert IfcDotProduct(IfcDirection(DirectionRatios=[0.0,0.0,1.0]),self.ExtrudedDirection) != 0.0 + + + + + +class IfcFace_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcFace" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + bounds = self.Bounds + + assert (sizeof([temp for temp in bounds if 'ifc2x3.ifcfaceouterbound' in typeof(temp)])) <= 1 + + + + + +def calc_IfcFaceBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + + + + + + + + + + + + + + + + + + + +class IfcFanType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcFanType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + +class IfcFillAreaStyle_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc2x3.ifccolour' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc2x3.ifcexternallydefinedhatchstyle' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_WR13: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "WR13" + + @staticmethod + def __call__(self): + + + assert IfcCorrectFillAreaStyle(self.FillStyles) + + + + + +class IfcFillAreaStyleHatching_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + startofnexthatchline = self.StartOfNextHatchLine + + assert not 'ifc2x3.ifctwodirectionrepeatfactor' in typeof(startofnexthatchline) + + + + +class IfcFillAreaStyleHatching_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + patternstart = self.PatternStart + + assert (not exists(patternstart)) or (patternstart.Dim == 2) + + + + +class IfcFillAreaStyleHatching_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + pointofreferencehatchline = self.PointOfReferenceHatchLine + + assert (not exists(pointofreferencehatchline)) or (pointofreferencehatchline.Dim == 2) + + + + + + + + + + + +class IfcFilterType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcFilterType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + +class IfcFlowMeterType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeterType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFooting_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + + + + + + + + + + +class IfcGasTerminalType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcGasTerminalType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcGasTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcGasTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcGeneralProfileProperties_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcGeneralProfileProperties" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + crosssectionarea = self.CrossSectionArea + + assert (not exists(crosssectionarea)) or (crosssectionarea > 0.) + + + + + +class IfcGeometricCurveSet_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricCurveSet" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Elements if 'ifc2x3.ifcsurface' in typeof(temp)])) == 0 + + + + + + + + + + + +class IfcGeometricRepresentationSubContext_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + parentcontext = self.ParentContext + + assert not 'ifc2x3.ifcgeometricrepresentationsubcontext' in typeof(parentcontext) + + + + +class IfcGeometricRepresentationSubContext_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + targetview = self.TargetView + userdefinedtargetview = self.UserDefinedTargetView + + assert (targetview != IfcGeometricProjectionEnum.USERDEFINED) or ((targetview == IfcGeometricProjectionEnum.USERDEFINED) and exists(userdefinedtargetview)) + + + + +def calc_IfcGeometricRepresentationSubContext_WorldCoordinateSystem(self): + parentcontext = self.ParentContext + return \ + parentcontext.WorldCoordinateSystem + + + +def calc_IfcGeometricRepresentationSubContext_CoordinateSpaceDimension(self): + parentcontext = self.ParentContext + return \ + parentcontext.CoordinateSpaceDimension + + + +def calc_IfcGeometricRepresentationSubContext_TrueNorth(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.TrueNorth,self.WorldCoordinateSystem.P[2 - 1]) + + + +def calc_IfcGeometricRepresentationSubContext_Precision(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.Precision,1) + + + + +class IfcGeometricSet_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricSet" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof([temp for temp in elements if temp.Dim != (elements[1 - 1].Dim)])) == 0 + + + + +def calc_IfcGeometricSet_Dim(self): + elements = self.Elements + return \ + elements[1 - 1].Dim + + + + +class IfcGrid_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcGrid" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + + + assert exists(self.ObjectPlacement) + + + + + +class IfcGridAxis_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + axiscurve = self.AxisCurve + + assert axiscurve.Dim == 2 + + + + +class IfcGridAxis_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + partofw = self.PartOfW + partofv = self.PartOfV + partofu = self.PartOfU + + assert (sizeof(partofu) == 1) ^ (sizeof(partofv) == 1) ^ (sizeof(partofw) == 1) + + + + + + + + + + + +def calc_IfcHalfSpaceSolid_Dim(self): + + return \ + 3 + + + + +class IfcHeatExchangerType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchangerType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcHumidifierType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifierType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcIShapeProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + flangethickness = self.FlangeThickness + + assert flangethickness < (overalldepth / 2.) + + + + +class IfcIShapeProfileDef_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + webthickness = self.WebThickness + + assert webthickness < overallwidth + + + + +class IfcIShapeProfileDef_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + overalldepth = self.OverallDepth + webthickness = self.WebThickness + flangethickness = self.FlangeThickness + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or ((filletradius <= ((overallwidth - webthickness) / 2.)) and (filletradius <= ((overalldepth - (2. * flangethickness)) / 2.))) + + + + + + + + +class IfcInventory_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcInventory" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.IsGroupedBy.RelatedObjects if not ('ifc2x3.ifcspace' in typeof(temp)) or ('ifc2x3.ifcasset' in typeof(temp)) or ('ifc2x3.ifcfurnishingelement' in typeof(temp))])) == 0 + + + + + + + + + + + + + + +class IfcLShapeProfileDef_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcLShapeProfileDef" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + depth = self.Depth + thickness = self.Thickness + + assert thickness < depth + + + + +class IfcLShapeProfileDef_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcLShapeProfileDef" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + width = self.Width + thickness = self.Thickness + + assert (not exists(width)) or (thickness < width) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcLine_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcLine" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + pnt = self.Pnt + dir = self.Dir + + assert dir.Dim == pnt.Dim + + + + + + + + +class IfcLocalPlacement_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcLocalPlacement" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + placementrelto = self.PlacementRelTo + relativeplacement = self.RelativePlacement + + assert IfcCorrectLocalPlacement(relativeplacement,placementrelto) + + + + + +class IfcLocalTime_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcLocalTime" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert IfcValidTime(self) + + + + + + + + + + + + + + + + + + + + +class IfcMaterialDefinitionRepresentation_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialDefinitionRepresentation" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc2x3.ifcstyledrepresentation' in typeof(temp)])) == 0 + + + + + + + + +def calc_IfcMaterialLayerSet_TotalThickness(self): + + return \ + IfcMlsTotalThickness(self) + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMechanicalMaterialProperties_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalMaterialProperties" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + youngmodulus = self.YoungModulus + + assert (not exists(youngmodulus)) or (youngmodulus >= 0.0) + + + + +class IfcMechanicalMaterialProperties_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalMaterialProperties" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + shearmodulus = self.ShearModulus + + assert (not exists(shearmodulus)) or (shearmodulus >= 0.0) + + + + + +class IfcMechanicalSteelMaterialProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalSteelMaterialProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + yieldstress = self.YieldStress + + assert (not exists(yieldstress)) or (yieldstress >= 0.) + + + + +class IfcMechanicalSteelMaterialProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalSteelMaterialProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + ultimatestress = self.UltimateStress + + assert (not exists(ultimatestress)) or (ultimatestress >= 0.) + + + + +class IfcMechanicalSteelMaterialProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalSteelMaterialProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + hardeningmodule = self.HardeningModule + + assert (not exists(hardeningmodule)) or (hardeningmodule >= 0.) + + + + +class IfcMechanicalSteelMaterialProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalSteelMaterialProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + proportionalstress = self.ProportionalStress + + assert (not exists(proportionalstress)) or (proportionalstress >= 0.) + + + + + + + + + + + + + + + + + + + + +class IfcMove_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcMove" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert sizeof(self.OperatesOn) >= 1 + + + + +class IfcMove_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcMove" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + operateson = self.OperatesOn + + assert (sizeof([temp for temp in operateson if (sizeof([temp2 for temp2 in temp.RelatedObjects if ('ifc2x3.ifcactor' in typeof(temp2)) or ('ifc2x3.ifcequipmentelement' in typeof(temp2)) or ('ifc2x3.ifcfurnishingelement' in typeof(temp2))])) >= 1])) >= 1 + + + + +class IfcMove_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcMove" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcNamedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcNamedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert IfcCorrectDimensions(self.UnitType,self.Dimensions) + + + + + +class IfcObject_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcObject" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + isdefinedby = self.IsDefinedBy + + assert (sizeof([temp for temp in isdefinedby if 'ifc2x3.ifcreldefinesbytype' in typeof(temp)])) <= 1 + + + + + + + + + + + +class IfcObjective_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcObjective" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + objectivequalifier = self.ObjectiveQualifier + + assert (objectivequalifier != IfcObjectiveEnum.USERDEFINED) or ((objectivequalifier == IfcObjectiveEnum.USERDEFINED) and exists(self.UserDefinedQualifier)) + + + + + +class IfcOccupant_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcOccupant" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not predefinedtype == IfcOccupantTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcOffsetCurve2D_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve2D" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 2 + + + + + +class IfcOffsetCurve3D_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve3D" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 3 + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcOrientedEdge_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcOrientedEdge" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + edgeelement = self.EdgeElement + + assert not 'ifc2x3.ifcorientededge' in typeof(edgeelement) + + + + +def calc_IfcOrientedEdge_EdgeStart(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeStart,edgeelement.EdgeEnd) + + + +def calc_IfcOrientedEdge_EdgeEnd(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeEnd,edgeelement.EdgeStart) + + + + + + + + + + + + + +class IfcPath_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPath" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert IfcPathHeadToTail(self) + + + + + + + + + + + + + + +class IfcPerson_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + familyname = self.FamilyName + givenname = self.GivenName + + assert exists(familyname) or exists(givenname) + + + + + + + + +class IfcPhysicalComplexQuantity_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert (sizeof([temp for temp in hasquantities if self == temp])) == 0 + + + + + + + + + + + +class IfcPile_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcPipeFittingType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFittingType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeSegmentType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegmentType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPixelTexture_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + width = self.Width + + assert width >= 1 + + + + +class IfcPixelTexture_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + height = self.Height + + assert height >= 1 + + + + +class IfcPixelTexture_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + colourcomponents = self.ColourComponents + + assert 1 <= colourcomponents <= 4 + + + + +class IfcPixelTexture_WR24: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "WR24" + + @staticmethod + def __call__(self): + width = self.Width + height = self.Height + pixel = self.Pixel + + assert sizeof(pixel) == (width * height) + + + + + +def calc_IfcPlacement_Dim(self): + location = self.Location + return \ + location.Dim + + + + + + + + + + + + + + + + + + + + + + +def calc_IfcPointOnCurve_Dim(self): + basiscurve = self.BasisCurve + return \ + basiscurve.Dim + + + + +def calc_IfcPointOnSurface_Dim(self): + basissurface = self.BasisSurface + return \ + basissurface.Dim + + + + +class IfcPolyLoop_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPolyLoop" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + polygon = self.Polygon + + assert (sizeof([temp for temp in polygon if temp.Dim != (polygon[1 - 1].Dim)])) == 0 + + + + + +class IfcPolygonalBoundedHalfSpace_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert polygonalboundary.Dim == 2 + + + + +class IfcPolygonalBoundedHalfSpace_WR42: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "WR42" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert (sizeof(typeof(polygonalboundary) * ['ifc2x3.ifcpolyline','ifc2x3.ifccompositecurve'])) == 1 + + + + + +class IfcPolyline_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcPolyline" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + points = self.Points + + assert (sizeof([temp for temp in points if temp.Dim != (points[1 - 1].Dim)])) == 0 + + + + + + + + +class IfcPostalAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPostalAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + internallocation = self.InternalLocation + addresslines = self.AddressLines + postalbox = self.PostalBox + town = self.Town + region = self.Region + postalcode = self.PostalCode + country = self.Country + + assert exists(internallocation) or exists(addresslines) or exists(postalbox) or exists(postalcode) or exists(town) or exists(region) or exists(country) + + + + + + + + + + + +class IfcPreDefinedDimensionSymbol_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcPreDefinedDimensionSymbol" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert self.Name in ['arclength','conicaltaper','counterbore','countersink','depth','diameter','plusminus','radius','slope','sphericaldiameter','sphericalradius','square'] + + + + + + + + +class IfcPreDefinedPointMarkerSymbol_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcPreDefinedPointMarkerSymbol" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert self.Name in ['asterisk','circle','dot','plus','square','triangle','x'] + + + + + + + + +class IfcPreDefinedTerminatorSymbol_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcPreDefinedTerminatorSymbol" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert self.Name in ['blankedarrow','blankedbox','blankeddot','dimensionorigin','filledarrow','filledbox','filleddot','integralsymbol','openarrow','slash','unfilledarrow'] + + + + + + + + + + + + + + + + + + + + +class IfcProcedure_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Decomposes if not 'ifc2x3.ifcrelnests' in typeof(temp)])) == 0 + + + + +class IfcProcedure_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.IsDecomposedBy if not 'ifc2x3.ifcrelnests' in typeof(temp)])) == 0 + + + + +class IfcProcedure_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProcedure_WR4: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "WR4" + + @staticmethod + def __call__(self): + proceduretype = self.ProcedureType + + assert (proceduretype != IfcProcedureTypeEnum.USERDEFINED) or ((proceduretype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.UserDefinedProcedureType)) + + + + + + + + +class IfcProduct_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcProduct" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + objectplacement = self.ObjectPlacement + representation = self.Representation + + assert (exists(representation) and exists(objectplacement)) or (exists(representation) and (not 'ifc2x3.ifcproductdefinitionshape' in typeof(representation))) or (not exists(representation)) + + + + + +class IfcProductDefinitionShape_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcProductDefinitionShape" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc2x3.ifcshapemodel' in typeof(temp)])) == 0 + + + + + + + + + + + + + + + + + +class IfcProject_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProject_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + representationcontexts = self.RepresentationContexts + + assert (sizeof([temp for temp in representationcontexts if 'ifc2x3.ifcgeometricrepresentationsubcontext' in typeof(temp)])) == 0 + + + + +class IfcProject_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + + + assert sizeof(self.Decomposes) == 0 + + + + + + + + + + + + + + + + + + + + +class IfcPropertyBoundedValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + lowerboundvalue = self.LowerBoundValue + + assert (not exists(upperboundvalue)) or (not exists(lowerboundvalue)) or (typeof(upperboundvalue) == typeof(lowerboundvalue)) + + + + +class IfcPropertyBoundedValue_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + lowerboundvalue = self.LowerBoundValue + + assert exists(upperboundvalue) or exists(lowerboundvalue) + + + + + + + + + + + +class IfcPropertyDependencyRelationship_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyDependencyRelationship" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + dependingproperty = self.DependingProperty + dependantproperty = self.DependantProperty + + assert dependingproperty != dependantproperty + + + + + +class IfcPropertyEnumeratedValue_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeratedValue" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + enumerationvalues = self.EnumerationValues + enumerationreference = self.EnumerationReference + + assert (not exists(enumerationreference)) or ((sizeof([temp for temp in enumerationvalues if temp in enumerationreference.EnumerationValues])) == sizeof(enumerationvalues)) + + + + + +class IfcPropertyEnumeration_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeration" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.EnumerationValues if not (typeof(self.EnumerationValues[1 - 1])) == typeof(temp)])) == 0 + + + + + +class IfcPropertyListValue_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyListValue" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.ListValues if not (typeof(self.ListValues[1 - 1])) == typeof(temp)])) == 0 + + + + + + + + +class IfcPropertySet_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySet_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + + + + + + + +class IfcPropertyTableValue_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + definedvalues = self.DefinedValues + + assert sizeof(definingvalues) == sizeof(definedvalues) + + + + +class IfcPropertyTableValue_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.DefiningValues if typeof(temp) != (typeof(self.DefiningValues[1 - 1]))])) == 0 + + + + +class IfcPropertyTableValue_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.DefinedValues if typeof(temp) != (typeof(self.DefinedValues[1 - 1]))])) == 0 + + + + + + + + +class IfcProxy_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcProxy" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcPumpType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPumpType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcQuantityArea_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.AREAUNIT) + + + + +class IfcQuantityArea_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + areavalue = self.AreaValue + + assert areavalue >= 0. + + + + + +class IfcQuantityCount_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityCount" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + countvalue = self.CountValue + + assert countvalue >= 0. + + + + + +class IfcQuantityLength_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + +class IfcQuantityLength_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + lengthvalue = self.LengthValue + + assert lengthvalue >= 0. + + + + + +class IfcQuantityTime_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.TIMEUNIT) + + + + +class IfcQuantityTime_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + timevalue = self.TimeValue + + assert timevalue >= 0. + + + + + +class IfcQuantityVolume_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.VOLUMEUNIT) + + + + +class IfcQuantityVolume_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + volumevalue = self.VolumeValue + + assert volumevalue >= 0. + + + + + +class IfcQuantityWeight_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.MASSUNIT) + + + + +class IfcQuantityWeight_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + weightvalue = self.WeightValue + + assert weightvalue >= 0. + + + + + + + + +class IfcRailing_WR61: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "WR61" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcRamp_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (hiindex(self.IsDecomposedBy) == 0) or ((hiindex(self.IsDecomposedBy) == 1) and (not exists(self.Representation))) + + + + + + + + + + + +class IfcRationalBezierCurve_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBezierCurve" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert sizeof(weightsdata) == sizeof(self.ControlPointsList) + + + + +class IfcRationalBezierCurve_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBezierCurve" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + + + assert IfcCurveWeightsPositive(self) + + + + +def calc_IfcRationalBezierCurve_Weights(self): + weightsdata = self.WeightsData + return \ + IfcListToArray(weightsdata,0,self.UpperIndexOnControlPoints) + + + + +class IfcRectangleHollowProfileDef_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert (wallthickness < (self.XDim / 2.)) and (wallthickness < (self.YDim / 2.)) + + + + +class IfcRectangleHollowProfileDef_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + outerfilletradius = self.OuterFilletRadius + + assert (not exists(outerfilletradius)) or ((outerfilletradius <= (self.XDim / 2.)) and (outerfilletradius <= (self.YDim / 2.))) + + + + +class IfcRectangleHollowProfileDef_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + innerfilletradius = self.InnerFilletRadius + + assert (not exists(innerfilletradius)) or ((innerfilletradius <= ((self.XDim / 2.) - wallthickness)) and (innerfilletradius <= ((self.YDim / 2.) - wallthickness))) + + + + + + + + + + + +class IfcRectangularTrimmedSurface_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + u1 = self.U1 + u2 = self.U2 + + assert u1 != u2 + + + + +class IfcRectangularTrimmedSurface_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + + assert v1 != v2 + + + + +class IfcRectangularTrimmedSurface_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + u1 = self.U1 + u2 = self.U2 + usense = self.Usense + + assert (('ifc2x3.ifcelementarysurface' in typeof(basissurface)) and (not 'ifc2x3.ifcplane' in typeof(basissurface))) or ('ifc2x3.ifcsurfaceofrevolution' in typeof(basissurface)) or (usense == (u2 > u1)) + + + + +class IfcRectangularTrimmedSurface_WR4: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "WR4" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + vsense = self.Vsense + + assert vsense == (v2 > v1) + + + + +def calc_IfcRectangularTrimmedSurface_Dim(self): + basissurface = self.BasisSurface + return \ + basissurface.Dim + + + + + + + + + + + + + + + + +class IfcReinforcingBar_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + barrole = self.BarRole + + assert (barrole != IfcReinforcingBarRoleEnum.USERDEFINED) or ((barrole == IfcReinforcingBarRoleEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + + + + +class IfcRelAssigns_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssigns" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatedobjects = self.RelatedObjects + relatedobjectstype = self.RelatedObjectsType + + assert IfcCorrectObjectAssignment(relatedobjectstype,relatedobjects) + + + + + +class IfcRelAssignsTasks_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsTasks" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert hiindex(self.RelatedObjects) == 1 + + + + +class IfcRelAssignsTasks_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsTasks" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + + + assert 'ifc2x3.ifctask' in (typeof(self.RelatedObjects[1 - 1])) + + + + +class IfcRelAssignsTasks_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsTasks" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + + + assert 'ifc2x3.ifcworkcontrol' in typeof(self.RelatingControl) + + + + + +class IfcRelAssignsToActor_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToActor" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatingactor = self.RelatingActor + + assert (sizeof([temp for temp in self.RelatedObjects if relatingactor == temp])) == 0 + + + + + +class IfcRelAssignsToControl_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToControl" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatingcontrol = self.RelatingControl + + assert (sizeof([temp for temp in self.RelatedObjects if relatingcontrol == temp])) == 0 + + + + + +class IfcRelAssignsToGroup_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToGroup" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatinggroup = self.RelatingGroup + + assert (sizeof([temp for temp in self.RelatedObjects if relatinggroup == temp])) == 0 + + + + + +class IfcRelAssignsToProcess_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProcess" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + + assert (sizeof([temp for temp in self.RelatedObjects if relatingprocess == temp])) == 0 + + + + + +class IfcRelAssignsToProduct_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProduct" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatingproduct = self.RelatingProduct + + assert (sizeof([temp for temp in self.RelatedObjects if relatingproduct == temp])) == 0 + + + + + + + + +class IfcRelAssignsToResource_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToResource" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatingresource = self.RelatingResource + + assert (sizeof([temp for temp in self.RelatedObjects if relatingresource == temp])) == 0 + + + + + +class IfcRelAssociates_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociates" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if not ('ifc2x3.ifcobjectdefinition' in typeof(temp)) or ('ifc2x3.ifcpropertydefinition' in typeof(temp))])) == 0 + + + + + + + + + + + + + + + + + + + + + + + +class IfcRelAssociatesMaterial_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if ('ifc2x3.ifcfeatureelementsubtraction' in typeof(temp)) or ('ifc2x3.ifcvirtualelement' in typeof(temp))])) == 0 + + + + +class IfcRelAssociatesMaterial_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if (not 'ifc2x3.ifcproduct' in typeof(temp)) and (not 'ifc2x3.ifctypeproduct' in typeof(temp))])) == 0 + + + + + + + + + + + +class IfcRelConnectsElements_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsElements" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcRelContainedInSpatialStructure_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRelContainedInSpatialStructure" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if 'ifc2x3.ifcspatialstructureelement' in typeof(temp)])) == 0 + + + + + + + + + + + +class IfcRelDecomposes_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRelDecomposes" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + + + + + + + + + + + + + + + + + + + +class IfcRelNests_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelNests" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if not typeof(self.RelatingObject) == typeof(temp)])) == 0 + + + + + + + + +class IfcRelOverridesProperties_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelOverridesProperties" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert sizeof(self.RelatedObjects) == 1 + + + + + + + + +class IfcRelReferencedInSpatialStructure_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRelReferencedInSpatialStructure" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if 'ifc2x3.ifcspatialstructureelement' in typeof(temp)])) == 0 + + + + + +class IfcRelSchedulesCostItems_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcRelSchedulesCostItems" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if not 'ifc2x3.ifccostitem' in typeof(temp)])) == 0 + + + + +class IfcRelSchedulesCostItems_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcRelSchedulesCostItems" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + + + assert 'ifc2x3.ifccostschedule' in typeof(self.RelatingControl) + + + + + +class IfcRelSequence_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + relatedprocess = self.RelatedProcess + + assert relatingprocess != relatedprocess + + + + + + + + +class IfcRelSpaceBoundary_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelSpaceBoundary" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatedbuildingelement = self.RelatedBuildingElement + physicalorvirtualboundary = self.PhysicalOrVirtualBoundary + + assert ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Physical) and (exists(relatedbuildingelement) and (not 'ifc2x3.ifcvirtualelement' in typeof(relatedbuildingelement)))) or ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Virtual) and ((not exists(relatedbuildingelement)) or ('ifc2x3.ifcvirtualelement' in typeof(relatedbuildingelement)))) or (physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.NotDefined) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcRevolvedAreaSolid_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Location.Coordinates[3 - 1]) == 0.0 + + + + +class IfcRevolvedAreaSolid_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Z.DirectionRatios[3 - 1]) == 0.0 + + + + +def calc_IfcRevolvedAreaSolid_AxisLine(self): + axis = self.Axis + return \ + IfcLine(Pnt=axis.Location, Dir=IfcVector(Orientation=axis.Z, Magnitude=1.0)) + + + + + + + + + + + + + +class IfcRoof_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (hiindex(self.IsDecomposedBy) == 0) or ((hiindex(self.IsDecomposedBy) == 1) and (not exists(self.Representation))) + + + + + + + + + + + +class IfcRoundedRectangleProfileDef_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRoundedRectangleProfileDef" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + roundingradius = self.RoundingRadius + + assert (roundingradius <= (self.XDim / 2.)) and (roundingradius <= (self.YDim / 2.)) + + + + + +def calc_IfcSIUnit_Dimensions(self): + + return \ + IfcDimensionsForSiUnit(self.Name) + + + + + + + + + + + + + + + + +class IfcSectionedSpine_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSpine_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSpine_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + spinecurve = self.SpineCurve + + assert spinecurve.Dim == 3 + + + + +def calc_IfcSectionedSpine_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcServiceLifeFactor_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcServiceLifeFactor" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not predefinedtype == IfcServiceLifeFactorTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcShapeModel_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcShapeModel" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + ofshapeaspect = self.OfShapeAspect + + assert (sizeof(self.OfProductRepresentation) == 1) ^ (sizeof(self.RepresentationMap) == 1) ^ (sizeof(ofshapeaspect) == 1) + + + + + +class IfcShapeRepresentation_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert 'ifc2x3.ifcgeometricrepresentationcontext' in typeof(self.ContextOfItems) + + + + +class IfcShapeRepresentation_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + items = self.Items + + assert (sizeof([temp for temp in items if ('ifc2x3.ifctopologicalrepresentationitem' in typeof(temp)) and (not (sizeof(['ifc2x3.ifcvertexpoint','ifc2x3.ifcedgecurve','ifc2x3.ifcfacesurface'] * typeof(temp))) == 1)])) == 0 + + + + +class IfcShapeRepresentation_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcShapeRepresentation_WR24: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "WR24" + + @staticmethod + def __call__(self): + + + assert IfcShapeRepresentationTypes(self.RepresentationType,self.Items) + + + + + +def calc_IfcShellBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcSlab_WR61: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "WR61" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +def calc_IfcSolidModel_Dim(self): + + return \ + 3 + + + + + + + + + + + + + +class IfcSpaceHeaterType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeaterType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcSpatialStructureElement_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialStructureElement" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + + + assert (hiindex(self.Decomposes) == 1) and ('ifc2x3.ifcrelaggregates' in (typeof(self.Decomposes[1 - 1]))) and (('ifc2x3.ifcproject' in (typeof(self.Decomposes[1 - 1].RelatingObject))) or ('ifc2x3.ifcspatialstructureelement' in (typeof(self.Decomposes[1 - 1].RelatingObject)))) + + + + + + + + + + + + + + +class IfcStair_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (hiindex(self.IsDecomposedBy) == 0) or ((hiindex(self.IsDecomposedBy) == 1) and (not exists(self.Representation))) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcStructuralLinearAction_WR61: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "WR61" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc2x3.ifcstructuralloadlinearforce','ifc2x3.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + + +def calc_IfcStructuralLinearActionVarying_VaryingAppliedLoads(self): + subsequentappliedloads = self.SubsequentAppliedLoads + return \ + IfcAddToBeginOfList(self.AppliedLoad,subsequentappliedloads) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcStructuralPlanarAction_WR61: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "WR61" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc2x3.ifcstructuralloadplanarforce','ifc2x3.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + + +def calc_IfcStructuralPlanarActionVarying_VaryingAppliedLoads(self): + subsequentappliedloads = self.SubsequentAppliedLoads + return \ + IfcAddToBeginOfList(self.AppliedLoad,subsequentappliedloads) + + + + +class IfcStructuralPointAction_WR61: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointAction" + RULE_NAME = "WR61" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc2x3.ifcstructuralloadsingleforce','ifc2x3.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralPointReaction_WR61: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointReaction" + RULE_NAME = "WR61" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc2x3.ifcstructuralloadsingleforce','ifc2x3.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + +class IfcStructuralProfileProperties_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralProfileProperties" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + sheardeformationareay = self.ShearDeformationAreaY + + assert (not exists(sheardeformationareay)) or (sheardeformationareay >= 0.) + + + + +class IfcStructuralProfileProperties_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralProfileProperties" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + sheardeformationareaz = self.ShearDeformationAreaZ + + assert (not exists(sheardeformationareaz)) or (sheardeformationareaz >= 0.) + + + + + + + + + + + +class IfcStructuralSteelProfileProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSteelProfileProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + shearareay = self.ShearAreaY + + assert (not exists(shearareay)) or (shearareay >= 0.) + + + + +class IfcStructuralSteelProfileProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSteelProfileProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + shearareaz = self.ShearAreaZ + + assert (not exists(shearareaz)) or (shearareaz >= 0.) + + + + + + + + + + + +class IfcStructuralSurfaceMemberVarying_WR61: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceMemberVarying" + RULE_NAME = "WR61" + + @staticmethod + def __call__(self): + + + assert exists(self.Thickness) + + + + +class IfcStructuralSurfaceMemberVarying_WR62: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceMemberVarying" + RULE_NAME = "WR62" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.VaryingThicknessLocation.ShapeRepresentations if not sizeof(temp.Items) == 1])) == 0 + + + + +class IfcStructuralSurfaceMemberVarying_WR63: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceMemberVarying" + RULE_NAME = "WR63" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.VaryingThicknessLocation.ShapeRepresentations if not ('ifc2x3.ifccartesianpoint' in (typeof(temp.Items[1 - 1]))) or ('ifc2x3.ifcpointonsurface' in (typeof(temp.Items[1 - 1])))])) == 0 + + + + +def calc_IfcStructuralSurfaceMemberVarying_VaryingThickness(self): + subsequentthickness = self.SubsequentThickness + return \ + IfcAddToBeginOfList(self.Thickness,subsequentthickness) + + + + +class IfcStructuredDimensionCallout_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcStructuredDimensionCallout" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + contents = self.Contents + + assert (sizeof([ato for ato in [con for con in self.contents if 'ifc2x3.ifcannotationtextoccurrence' in typeof(con)] if not ato.Name in ['dimensionvalue','tolerancevalue','unittext','prefixtext','suffixtext']])) == 0 + + + + + + + + +class IfcStyledItem_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcStyledItem" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + styles = self.Styles + + assert sizeof(styles) == 1 + + + + +class IfcStyledItem_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcStyledItem" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + item = self.Item + + assert not 'ifc2x3.ifcstyleditem' in typeof(item) + + + + + +class IfcStyledRepresentation_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcStyledRepresentation" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc2x3.ifcstyleditem' in typeof(temp)])) == 0 + + + + + + + + + + + + + + + + + +class IfcSurfaceOfLinearExtrusion_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceOfLinearExtrusion" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + depth = self.Depth + + assert depth > 0. + + + + +def calc_IfcSurfaceOfLinearExtrusion_ExtrusionAxis(self): + extrudeddirection = self.ExtrudedDirection + depth = self.Depth + return \ + IfcVector(Orientation=extrudeddirection, Magnitude=depth) + + + + +def calc_IfcSurfaceOfRevolution_AxisLine(self): + axisposition = self.AxisPosition + return \ + IfcLine(Pnt=axisposition.Location, Dir=IfcVector(Orientation=axisposition.Z, Magnitude=1.0)) + + + + +class IfcSurfaceStyle_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc2x3.ifcsurfacestyleshading' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc2x3.ifcsurfacestylelighting' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_WR13: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "WR13" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc2x3.ifcsurfacestylerefraction' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_WR14: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "WR14" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc2x3.ifcsurfacestylewithtextures' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_WR15: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "WR15" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc2x3.ifcexternallydefinedsurfacestyle' in typeof(style)])) <= 1 + + + + + + + + + + + + + + + + + + + + + + + +class IfcSweptAreaSolid_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcSweptAreaSolid" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + sweptarea = self.SweptArea + + assert sweptarea.ProfileType == IfcProfileTypeEnum.Area + + + + + +class IfcSweptDiskSolid_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSweptDiskSolid_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + radius = self.Radius + innerradius = self.InnerRadius + + assert (not exists(innerradius)) or (radius > innerradius) + + + + + +class IfcSweptSurface_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcSweptSurface" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + sweptcurve = self.SweptCurve + + assert not 'ifc2x3.ifcderivedprofiledef' in typeof(sweptcurve) + + + + +class IfcSweptSurface_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcSweptSurface" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + sweptcurve = self.SweptCurve + + assert sweptcurve.ProfileType == IfcProfileTypeEnum.Curve + + + + +def calc_IfcSweptSurface_Dim(self): + position = self.Position + return \ + position.Dim + + + + + + + + + + + + + + + + +class IfcTShapeProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < depth + + + + +class IfcTShapeProfileDef_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcTable_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + rows = self.Rows + + assert (sizeof([temp for temp in rows if hiindex(temp.RowCells) != (hiindex(rows[1 - 1].RowCells))])) == 0 + + + + +class IfcTable_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + rows = self.Rows + + assert (sizeof([temp for temp in rows if hiindex(temp.RowCells) != (hiindex(rows[1 - 1].RowCells))])) == 0 + + + + +class IfcTable_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + numberofheadings = self.NumberOfHeadings + + assert 0 <= numberofheadings <= 1 + + + + +def calc_IfcTable_NumberOfCellsInRow(self): + rows = self.Rows + return \ + hiindex(rows[1 - 1].RowCells) + + + +def calc_IfcTable_NumberOfHeadings(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if temp.IsHeading]) + + + +def calc_IfcTable_NumberOfDataRows(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if not temp.IsHeading]) + + + + + + + +class IfcTankType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTankType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTask_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Decomposes if not 'ifc2x3.ifcrelnests' in typeof(temp)])) == 0 + + + + +class IfcTask_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.IsDecomposedBy if not 'ifc2x3.ifcrelnests' in typeof(temp)])) == 0 + + + + +class IfcTask_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcTelecomAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTelecomAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + telephonenumbers = self.TelephoneNumbers + facsimilenumbers = self.FacsimileNumbers + pagernumber = self.PagerNumber + electronicmailaddresses = self.ElectronicMailAddresses + wwwhomepageurl = self.WWWHomePageURL + + assert exists(telephonenumbers) or exists(pagernumber) or exists(facsimilenumbers) or exists(electronicmailaddresses) or exists(wwwhomepageurl) + + + + + +class IfcTendon_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + + + + +class IfcTextLiteralWithExtent_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcTextLiteralWithExtent" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + extent = self.Extent + + assert not 'ifc2x3.ifcplanarbox' in typeof(extent) + + + + + + + + +class IfcTextStyleFontModel_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcTextStyleFontModel" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert ('ifc2x3.ifclengthmeasure' in typeof(self.FontSize)) and (self.FontSize > 0.) + + + + + + + + + + + + + + + + + + + + +class IfcTextureMap_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcTextureMap" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc2x3.ifcshellbasedsurfacemodel','ifc2x3.ifcfacebasedsurfacemodel','ifc2x3.ifcfacetedbrep','ifc2x3.ifcfacetedbrepwithvoids'] * (typeof(self.AnnotatedSurface[1 - 1].Item)))) >= 1 + + + + + + + + + + + + + + + + + +class IfcTimeSeriesSchedule_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcTimeSeriesSchedule" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + timeseriesscheduletype = self.TimeSeriesScheduleType + + assert (not timeseriesscheduletype == IfcTimeSeriesScheduleTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + + + + +class IfcTopologyRepresentation_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc2x3.ifctopologicalrepresentationitem' in typeof(temp)])) == 0 + + + + +class IfcTopologyRepresentation_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcTopologyRepresentation_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + + + assert IfcTopologyRepresentationTypes(self.RepresentationType,self.Items) + + + + + + + + + + + + + + + + + +class IfcTrimmedCurve_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + trim1 = self.Trim1 + + assert (hiindex(trim1) == 1) or ((typeof(trim1[1 - 1])) != (typeof(trim1[2 - 1]))) + + + + +class IfcTrimmedCurve_WR42: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "WR42" + + @staticmethod + def __call__(self): + trim2 = self.Trim2 + + assert (hiindex(trim2) == 1) or ((typeof(trim2[1 - 1])) != (typeof(trim2[2 - 1]))) + + + + +class IfcTrimmedCurve_WR43: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "WR43" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert not 'ifc2x3.ifcboundedcurve' in typeof(basiscurve) + + + + + +class IfcTubeBundleType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundleType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcTypeObject_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcTypeProduct_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcTypeProduct" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + + + assert (not exists(lambda: self.ObjectTypeOf[1 - 1])) or ((sizeof([temp for temp in self.ObjectTypeOf[1 - 1].RelatedObjects if not 'ifc2x3.ifcproduct' in typeof(temp)])) == 0) + + + + + +class IfcUShapeProfileDef_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + +class IfcUShapeProfileDef_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcUnitAssignment_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcUnitAssignment" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + units = self.Units + + assert IfcCorrectUnitAssignment(units) + + + + + +class IfcUnitaryEquipmentType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipmentType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcValveType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcValveType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVector_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcVector" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + magnitude = self.Magnitude + + assert magnitude >= 0.0 + + + + +def calc_IfcVector_Dim(self): + orientation = self.Orientation + return \ + orientation.Dim + + + + + + + + + + + + + + + + +class IfcVibrationIsolatorType_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolatorType" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcWall_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.HasAssociations if 'ifc2x3.ifcrelassociatesmaterial' in typeof(temp)])) <= 1 + + + + + +class IfcWallStandardCase_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcWallStandardCase" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc2x3.ifcrelassociates.relatedobjects') if ('ifc2x3.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc2x3.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + + + + + + + + + + + + + +class IfcWindowLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not (not exists(liningdepth)) and exists(liningthickness) + + + + +class IfcWindowLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + firsttransomoffset = self.FirstTransomOffset + secondtransomoffset = self.SecondTransomOffset + + assert not (not exists(firsttransomoffset)) and exists(secondtransomoffset) + + + + +class IfcWindowLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + firstmullionoffset = self.FirstMullionOffset + secondmullionoffset = self.SecondMullionOffset + + assert not (not exists(firstmullionoffset)) and exists(secondmullionoffset) + + + + +class IfcWindowLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and ('ifc2x3.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1]))) + + + + + + + + + + + +class IfcWorkControl_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcWorkControl" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + workcontroltype = self.WorkControlType + + assert (workcontroltype != IfcWorkControlTypeEnum.USERDEFINED) or ((workcontroltype == IfcWorkControlTypeEnum.USERDEFINED) and exists(self.UserDefinedControlType)) + + + + + + + + + + + +class IfcZShapeProfileDef_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcZShapeProfileDef" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + + +class IfcZone_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcZone" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.IsGroupedBy.RelatedObjects if not ('ifc2x3.ifczone' in typeof(temp)) or ('ifc2x3.ifcspace' in typeof(temp))])) == 0 + + + + + +class IfcRepresentationContextSameWCS: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcGeometricRepresentationContext = file.by_type("IfcGeometricRepresentationContext") + isdifferent = False + if sizeof(IfcGeometricRepresentationContext) > 1: + for i in range(2, hiindex(IfcGeometricRepresentationContext) + 1): + if (IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem) != (IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem): + isdifferent = (not IfcSameValidPrecision(IfcGeometricRepresentationContext[1 - 1].Precision,IfcGeometricRepresentationContext[i - 1].Precision)) or (not IfcSameAxis2Placement(IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[1 - 1].Precision)) + if isdifferent == True: + break + + assert isdifferent == False + + + + + +class IfcSingleProjectInstance: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcProject = file.by_type("IfcProject") + + + + assert sizeof(IfcProject) <= 1 + + + + +def IfcAddToBeginOfList(ascalar, alist): + result = [] + if not exists(ascalar): + result = alist + else: + result = result + ascalar + if hiindex(alist) >= 1: + for i in range(1, hiindex(alist) + 1): + temp = list(result) + temp[i - 1] = alist[i - 1] + result = temp + return result + + +def IfcBaseAxis(dim, axis1, axis2, axis3): + + + + if dim == 3: + d1 = nvl(IfcNormalise(axis3),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,axis1) + u = [d2,IfcSecondProjAxis(d1,d2,axis2),d1] + else: + if exists(axis1): + d1 = IfcNormalise(axis1) + u = [d1,IfcOrthogonalComplement(d1)] + if exists(axis2): + factor = IfcDotProduct(axis2,u[2 - 1]) + if factor < 0.0: + u[2 - 1].DirectionRatios[1 - 1] = -u[2 - 1].DirectionRatios[1 - 1] + u[2 - 1].DirectionRatios[2 - 1] = -u[2 - 1].DirectionRatios[2 - 1] + else: + if exists(axis2): + d1 = IfcNormalise(axis2) + u = [IfcOrthogonalComplement(d1),d1] + u[1 - 1].DirectionRatios[1 - 1] = -u[1 - 1].DirectionRatios[1 - 1] + u[1 - 1].DirectionRatios[2 - 1] = -u[1 - 1].DirectionRatios[2 - 1] + else: + u = [IfcDirection(DirectionRatios=[1.0,0.0]),IfcDirection(DirectionRatios=[0.0,1.0])] + return u + + +def IfcBooleanChoose(b, choice1, choice2): + + if b: + return choice1 + else: + return choice2 + + +def IfcBuild2Axes(refdirection): + d = nvl(IfcNormalise(refdirection),IfcDirection(DirectionRatios=[1.0,0.0])) + return [d,IfcOrthogonalComplement(d)] + + +def IfcBuildAxes(axis, refdirection): + + d1 = nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,refdirection) + return [d2,IfcNormalise(IfcCrossProduct(d1,d2)).Orientation,d1] + + +def IfcCorrectDimensions(m, dim): + + if m == lengthunit: + if dim == IfcDimensionalExponents(1,0,0,0,0,0,0): + return True + else: + return False + elif m == massunit: + if dim == IfcDimensionalExponents(0,1,0,0,0,0,0): + return True + else: + return False + elif m == timeunit: + if dim == IfcDimensionalExponents(0,0,1,0,0,0,0): + return True + else: + return False + elif m == electriccurrentunit: + if dim == IfcDimensionalExponents(0,0,0,1,0,0,0): + return True + else: + return False + elif m == thermodynamictemperatureunit: + if dim == IfcDimensionalExponents(0,0,0,0,1,0,0): + return True + else: + return False + elif m == amountofsubstanceunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,1,0): + return True + else: + return False + elif m == luminousintensityunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == planeangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == solidangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == areaunit: + if dim == IfcDimensionalExponents(2,0,0,0,0,0,0): + return True + else: + return False + elif m == volumeunit: + if dim == IfcDimensionalExponents(3,0,0,0,0,0,0): + return True + else: + return False + elif m == absorbeddoseunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == radioactivityunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == electriccapacitanceunit: + if dim == IfcDimensionalExponents(-2,1,4,1,0,0,0): + return True + else: + return False + elif m == doseequivalentunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == electricchargeunit: + if dim == IfcDimensionalExponents(0,0,1,1,0,0,0): + return True + else: + return False + elif m == electricconductanceunit: + if dim == IfcDimensionalExponents(-2,-1,3,2,0,0,0): + return True + else: + return False + elif m == electricvoltageunit: + if dim == IfcDimensionalExponents(2,1,-3,-1,0,0,0): + return True + else: + return False + elif m == electricresistanceunit: + if dim == IfcDimensionalExponents(2,1,-3,-2,0,0,0): + return True + else: + return False + elif m == energyunit: + if dim == IfcDimensionalExponents(2,1,-2,0,0,0,0): + return True + else: + return False + elif m == forceunit: + if dim == IfcDimensionalExponents(1,1,-2,0,0,0,0): + return True + else: + return False + elif m == frequencyunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == inductanceunit: + if dim == IfcDimensionalExponents(2,1,-2,-2,0,0,0): + return True + else: + return False + elif m == illuminanceunit: + if dim == IfcDimensionalExponents(-2,0,0,0,0,0,1): + return True + else: + return False + elif m == luminousfluxunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == magneticfluxunit: + if dim == IfcDimensionalExponents(2,1,-2,-1,0,0,0): + return True + else: + return False + elif m == magneticfluxdensityunit: + if dim == IfcDimensionalExponents(0,1,-2,-1,0,0,0): + return True + else: + return False + elif m == powerunit: + if dim == IfcDimensionalExponents(2,1,-3,0,0,0,0): + return True + else: + return False + elif m == pressureunit: + if dim == IfcDimensionalExponents(-1,1,-2,0,0,0,0): + return True + else: + return False + else: + return unknown + + +def IfcCorrectFillAreaStyle(styles): + hatching = 0 + tiles = 0 + colour = 0 + external = 0 + external = sizeof([style for style in styles if 'ifc2x3.ifcexternallydefinedhatchstyle' in typeof(style)]) + hatching = sizeof([style for style in styles if 'ifc2x3.ifcfillareastylehatching' in typeof(style)]) + tiles = sizeof([style for style in styles if 'ifc2x3.ifcfillareastyletiles' in typeof(style)]) + colour = sizeof([style for style in styles if 'ifc2x3.ifccolour' in typeof(style)]) + if external > 1: + return False + if (external == 1) and ((hatching > 0) or (tiles > 0) or (colour > 0)): + return False + if colour > 1: + return False + if (hatching > 0) and (tiles > 0): + return False + return True + + +def IfcCorrectLocalPlacement(axisplacement, relplacement): + + if exists(relplacement): + if 'ifc2x3.ifcgridplacement' in typeof(relplacement): + return None + if 'ifc2x3.ifclocalplacement' in typeof(relplacement): + if 'ifc2x3.ifcaxis2placement2d' in typeof(axisplacement): + return True + if 'ifc2x3.ifcaxis2placement3d' in typeof(axisplacement): + if relplacement.RelativePlacement.Dim == 3: + return True + else: + return False + return True + return None + + +def IfcCorrectObjectAssignment(constraint, objects): + count = 0 + if not exists(constraint): + return True + if constraint == IfcObjectTypeEnum.NOTDEFINED: + return True + elif constraint == IfcObjectTypeEnum.PRODUCT: + count = sizeof([temp for temp in objects if not 'ifc2x3.ifcproduct' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROCESS: + count = sizeof([temp for temp in objects if not 'ifc2x3.ifcprocess' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.CONTROL: + count = sizeof([temp for temp in objects if not 'ifc2x3.ifccontrol' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.RESOURCE: + count = sizeof([temp for temp in objects if not 'ifc2x3.ifcresource' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.ACTOR: + count = sizeof([temp for temp in objects if not 'ifc2x3.ifcactor' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.GROUP: + count = sizeof([temp for temp in objects if not 'ifc2x3.ifcgroup' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROJECT: + count = sizeof([temp for temp in objects if not 'ifc2x3.ifcproject' in typeof(temp)]) + return count == 0 + else: + return None + + +def IfcCorrectUnitAssignment(units): + namedunitnumber = 0 + derivedunitnumber = 0 + monetaryunitnumber = 0 + namedunitnames = express_set([]) + derivedunitnames = express_set([]) + namedunitnumber = sizeof([temp for temp in units if ('ifc2x3.ifcnamedunit' in typeof(temp)) and (not temp.UnitType == IfcUnitEnum.USERDEFINED)]) + derivedunitnumber = sizeof([temp for temp in units if ('ifc2x3.ifcderivedunit' in typeof(temp)) and (not temp.UnitType == IfcDerivedUnitEnum.USERDEFINED)]) + monetaryunitnumber = sizeof([temp for temp in units if 'ifc2x3.ifcmonetaryunit' in typeof(temp)]) + for i in range(1, sizeof(units) + 1): + if ('ifc2x3.ifcnamedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcUnitEnum.USERDEFINED): + namedunitnames = namedunitnames + (units[i - 1].UnitType) + if ('ifc2x3.ifcderivedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcDerivedUnitEnum.USERDEFINED): + derivedunitnames = derivedunitnames + (units[i - 1].UnitType) + return (sizeof(namedunitnames) == namedunitnumber) and (sizeof(derivedunitnames) == derivedunitnumber) and (monetaryunitnumber <= 1) + + +def IfcCrossProduct(arg1, arg2): + + + + + if ((not exists(arg1)) or (arg1.Dim == 2)) or ((not exists(arg2)) or (arg2.Dim == 2)): + return None + else: + v1 = IfcNormalise(arg1).DirectionRatios + v2 = IfcNormalise(arg2).DirectionRatios + res = IfcDirection(DirectionRatios=[((v1[2 - 1]) * (v2[3 - 1])) - ((v1[3 - 1]) * (v2[2 - 1])),((v1[3 - 1]) * (v2[1 - 1])) - ((v1[1 - 1]) * (v2[3 - 1])),((v1[1 - 1]) * (v2[2 - 1])) - ((v1[2 - 1]) * (v2[1 - 1]))]) + mag = 0.0 + for i in range(1, 3 + 1): + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=arg1, Magnitude=0.0) + return result + + +def IfcCurveDim(curve): + + if 'ifc2x3.ifcline' in typeof(curve): + return curve.Pnt.Dim + if 'ifc2x3.ifcconic' in typeof(curve): + return curve.Position.Dim + if 'ifc2x3.ifcpolyline' in typeof(curve): + return curve.Points[1 - 1].Dim + if 'ifc2x3.ifctrimmedcurve' in typeof(curve): + return IfcCurveDim(curve.BasisCurve) + if 'ifc2x3.ifccompositecurve' in typeof(curve): + return curve.Segments[1 - 1].Dim + if 'ifc2x3.ifcbsplinecurve' in typeof(curve): + return curve.ControlPointsList[1 - 1].Dim + if 'ifc2x3.ifcoffsetcurve2d' in typeof(curve): + return 2 + if 'ifc2x3.ifcoffsetcurve3d' in typeof(curve): + return 3 + return None + + +def IfcCurveWeightsPositive(b): + result = True + for i in range(0, b.UpperIndexOnControlPoints + 1): + if (b.Weights[i - 1]) <= 0.0: + result = False + return result + return result + + +def IfcDeriveDimensionalExponents(unitelements): + result = IfcDimensionalExponents(0,0,0,0,0,0,0) + for i in range(loindex(unitelements), hiindex(unitelements) + 1): + result.LengthExponent = result.LengthExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LengthExponent)) + result.MassExponent = result.MassExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.MassExponent)) + result.TimeExponent = result.TimeExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.TimeExponent)) + result.ElectricCurrentExponent = result.ElectricCurrentExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ElectricCurrentExponent)) + result.ThermodynamicTemperatureExponent = result.ThermodynamicTemperatureExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ThermodynamicTemperatureExponent)) + result.AmountOfSubstanceExponent = result.AmountOfSubstanceExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.AmountOfSubstanceExponent)) + result.LuminousIntensityExponent = result.LuminousIntensityExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LuminousIntensityExponent)) + return result + + +def IfcDimensionsForSiUnit(n): + + if n == metre: + return IfcDimensionalExponents(1,0,0,0,0,0,0) + elif n == square_metre: + return IfcDimensionalExponents(2,0,0,0,0,0,0) + elif n == cubic_metre: + return IfcDimensionalExponents(3,0,0,0,0,0,0) + elif n == gram: + return IfcDimensionalExponents(0,1,0,0,0,0,0) + elif n == second: + return IfcDimensionalExponents(0,0,1,0,0,0,0) + elif n == ampere: + return IfcDimensionalExponents(0,0,0,1,0,0,0) + elif n == kelvin: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == mole: + return IfcDimensionalExponents(0,0,0,0,0,1,0) + elif n == candela: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == radian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == steradian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == hertz: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == newton: + return IfcDimensionalExponents(1,1,-2,0,0,0,0) + elif n == pascal: + return IfcDimensionalExponents(-1,1,-2,0,0,0,0) + elif n == joule: + return IfcDimensionalExponents(2,1,-2,0,0,0,0) + elif n == watt: + return IfcDimensionalExponents(2,1,-3,0,0,0,0) + elif n == coulomb: + return IfcDimensionalExponents(0,0,1,1,0,0,0) + elif n == volt: + return IfcDimensionalExponents(2,1,-3,-1,0,0,0) + elif n == farad: + return IfcDimensionalExponents(-2,-1,4,1,0,0,0) + elif n == ohm: + return IfcDimensionalExponents(2,1,-3,-2,0,0,0) + elif n == siemens: + return IfcDimensionalExponents(-2,-1,3,2,0,0,0) + elif n == weber: + return IfcDimensionalExponents(2,1,-2,-1,0,0,0) + elif n == tesla: + return IfcDimensionalExponents(0,1,-2,-1,0,0,0) + elif n == henry: + return IfcDimensionalExponents(2,1,-2,-2,0,0,0) + elif n == degree_celsius: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == lumen: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == lux: + return IfcDimensionalExponents(-2,0,0,0,0,0,1) + elif n == becquerel: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == gray: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + elif n == sievert: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + else: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + + +def IfcDotProduct(arg1, arg2): + + + + if (not exists(arg1)) or (not exists(arg2)): + scalar = None + else: + if arg1.Dim != arg2.Dim: + scalar = None + else: + vec1 = IfcNormalise(arg1) + vec2 = IfcNormalise(arg2) + ndim = arg1.Dim + scalar = 0.0 + for i in range(1, ndim + 1): + scalar = scalar + ((vec1.DirectionRatios[i - 1]) * (vec2.DirectionRatios[i - 1])) + return scalar + + +def IfcFirstProjAxis(zaxis, arg): + + + + + if not exists(zaxis): + return None + else: + z = IfcNormalise(zaxis) + if not exists(arg): + if z.DirectionRatios != [1.0,0.0,0.0]: + v = IfcDirection(DirectionRatios=[1.0,0.0,0.0]) + else: + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + if arg.Dim != 3: + return None + if IfcCrossProduct(arg,z).Magnitude == 0.0: + return None + else: + v = IfcNormalise(arg) + xvec = IfcScalarTimesVector(IfcDotProduct(v,z),z) + xaxis = IfcVectorDifference(v,xvec).Orientation + xaxis = IfcNormalise(xaxis) + return xaxis + + +def IfcLeapYear(year): + + if (((year % 4) == 0) and ((year % 100) != 0)) or ((year % 400) == 0): + return True + else: + return False + + +def IfcListToArray(lis, low, u): + + + n = sizeof(lis) + if n != (u - low + 1): + return None + else: + res = ([lis[1 - 1]] * n) + for i in range(2, n + 1): + temp = list(res) + temp[low - 1] = lis[i - 1] + res = temp + return res + + +def IfcLoopHeadToTail(aloop): + + p = True + n = sizeof(aloop.EdgeList) + for i in range(2, n + 1): + p = p and ((aloop.EdgeList[i - 1].EdgeEnd) == (aloop.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcMlsTotalThickness(layerset): + max = layerset.MaterialLayers[1 - 1].LayerThickness + if sizeof(layerset.MaterialLayers) > 1: + for i in range(2, hiindex(layerset.MaterialLayers) + 1): + max = max + (layerset.MaterialLayers[i - 1].LayerThickness) + return max + + +def IfcNormalise(arg): + + v = IfcDirection(DirectionRatios=[1.,0.]) + vec = IfcVector(Orientation=IfcDirection(DirectionRatios=[1.,0.]), Magnitude=1.) + + result = v + if not exists(arg): + return None + else: + ndim = arg.Dim + if 'ifc2x3.ifcvector' in typeof(arg): + v.DirectionRatios = arg.Orientation.DirectionRatios + vec.Magnitude = arg.Magnitude + vec.Orientation = v + if arg.Magnitude == 0.0: + return None + else: + vec.Magnitude = 1.0 + else: + v.DirectionRatios = arg.DirectionRatios + mag = 0.0 + for i in range(1, ndim + 1): + mag = mag + ((v.DirectionRatios[i - 1]) * (v.DirectionRatios[i - 1])) + if mag > 0.0: + mag = sqrt(mag) + for i in range(1, ndim + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = (v.DirectionRatios[i - 1]) / mag + v.DirectionRatios = temp + if 'ifc2x3.ifcvector' in typeof(arg): + vec.Orientation = v + result = vec + else: + result = v + else: + return None + return result + + +def IfcOrthogonalComplement(vec): + + if (not exists(vec)) or (vec.Dim != 2): + return None + else: + result = IfcDirection(DirectionRatios=[-vec.DirectionRatios[2 - 1],vec.DirectionRatios[1 - 1]]) + return result + + +def IfcPathHeadToTail(apath): + n = 0 + p = unknown + n = sizeof(apath.EdgeList) + for i in range(2, n + 1): + p = p and ((apath.EdgeList[i - 1].EdgeEnd) == (apath.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcSameAxis2Placement(ap1, ap2, epsilon): + + return (IfcSameDirection(ap1.P[1 - 1],ap2.P[1 - 1],epsilon)) and (IfcSameDirection(ap1.P[2 - 1],ap2.P[2 - 1],epsilon)) and IfcSameCartesianPoint(ap1.Location,ap1.Location,epsilon) + + +def IfcSameCartesianPoint(cp1, cp2, epsilon): + cp1x = cp1.Coordinates[1 - 1] + cp1y = cp1.Coordinates[2 - 1] + cp1z = 0 + cp2x = cp2.Coordinates[1 - 1] + cp2y = cp2.Coordinates[2 - 1] + cp2z = 0 + if sizeof(cp1.Coordinates) > 2: + cp1z = cp1.Coordinates[3 - 1] + if sizeof(cp2.Coordinates) > 2: + cp2z = cp2.Coordinates[3 - 1] + return IfcSameValue(cp1x,cp2x,epsilon) and IfcSameValue(cp1y,cp2y,epsilon) and IfcSameValue(cp1z,cp2z,epsilon) + + +def IfcSameDirection(dir1, dir2, epsilon): + dir1x = dir1.DirectionRatios[1 - 1] + dir1y = dir1.DirectionRatios[2 - 1] + dir1z = 0 + dir2x = dir2.DirectionRatios[1 - 1] + dir2y = dir2.DirectionRatios[2 - 1] + dir2z = 0 + if sizeof(dir1.DirectionRatios) > 2: + dir1z = dir1.DirectionRatios[3 - 1] + if sizeof(dir2.DirectionRatios) > 2: + dir2z = dir2.DirectionRatios[3 - 1] + return IfcSameValue(dir1x,dir2x,epsilon) and IfcSameValue(dir1y,dir2y,epsilon) and IfcSameValue(dir1z,dir2z,epsilon) + + +def IfcSameValidPrecision(epsilon1, epsilon2): + + defaulteps = 0.000001 + derivationofeps = 1.001 + uppereps = 1.0 + valideps1 = nvl(epsilon1,defaulteps) + valideps2 = nvl(epsilon2,defaulteps) + return (0.0 < valideps1) and (valideps1 <= (derivationofeps * valideps2)) and (valideps2 <= (derivationofeps * valideps1)) and (valideps2 < uppereps) + + +def IfcSameValue(value1, value2, epsilon): + + defaulteps = 0.000001 + valideps = nvl(epsilon,defaulteps) + return ((value1 + valideps) > value2) and (value1 < (value2 + valideps)) + + +def IfcScalarTimesVector(scalar, vec): + + + + if (not exists(scalar)) or (not exists(vec)): + return None + else: + if 'ifc2x3.ifcvector' in typeof(vec): + v = vec.Orientation + mag = scalar * vec.Magnitude + else: + v = vec + mag = scalar + if mag < 0.0: + for i in range(1, sizeof(v.DirectionRatios) + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = -v.DirectionRatios[i - 1] + v.DirectionRatios = temp + mag = -mag + result = IfcVector(Orientation=IfcNormalise(v), Magnitude=mag) + return result + + +def IfcSecondProjAxis(zaxis, xaxis, arg): + + + + if not exists(arg): + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + v = arg + temp = IfcScalarTimesVector(IfcDotProduct(v,zaxis),zaxis) + yaxis = IfcVectorDifference(v,temp) + temp = IfcScalarTimesVector(IfcDotProduct(v,xaxis),xaxis) + yaxis = IfcVectorDifference(yaxis,temp) + yaxis = IfcNormalise(yaxis) + return yaxis.Orientation + + +def IfcShapeRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'curve2d': + count = sizeof([temp for temp in items if ('ifc2x3.ifccurve' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'annotation2d': + count = sizeof([temp for temp in items if (sizeof(typeof(temp) * ['ifc2x3.ifcpoint','ifc2x3.ifccurve','ifc2x3.ifcgeometriccurveset','ifc2x3.ifcannotationfillarea','ifc2x3.ifcdefinedsymbol','ifc2x3.ifctextliteral','ifc2x3.ifcdraughtingcallout'])) == 1]) + elif reptype.lower() == 'geometricset': + count = sizeof([temp for temp in items if ('ifc2x3.ifcgeometricset' in typeof(temp)) or ('ifc2x3.ifcpoint' in typeof(temp)) or ('ifc2x3.ifccurve' in typeof(temp)) or ('ifc2x3.ifcsurface' in typeof(temp))]) + elif reptype.lower() == 'geometriccurveset': + count = sizeof([temp for temp in items if ('ifc2x3.ifcgeometriccurveset' in typeof(temp)) or ('ifc2x3.ifcgeometricset' in typeof(temp)) or ('ifc2x3.ifcpoint' in typeof(temp)) or ('ifc2x3.ifccurve' in typeof(temp))]) + for i in range(1, hiindex(items) + 1): + if 'ifc2x3.ifcgeometricset' in (typeof(items[i - 1])): + if (sizeof([temp for temp in items[i - 1].Elements if 'ifc2x3.ifcsurface' in typeof(temp)])) > 0: + count = count - 1 + elif reptype.lower() == 'surfacemodel': + count = sizeof([temp for temp in items if (sizeof(['ifc2x3.ifcshellbasedsurfacemodel','ifc2x3.ifcfacebasedsurfacemodel','ifc2x3.ifcfacetedbrep','ifc2x3.ifcfacetedbrepwithvoids'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'solidmodel': + count = sizeof([temp for temp in items if 'ifc2x3.ifcsolidmodel' in typeof(temp)]) + elif reptype.lower() == 'sweptsolid': + count = sizeof([temp for temp in items if 'ifc2x3.ifcsweptareasolid' in typeof(temp)]) + elif reptype.lower() == 'csg': + count = sizeof([temp for temp in items if 'ifc2x3.ifcbooleanresult' in typeof(temp)]) + elif reptype.lower() == 'clipping': + count = sizeof([temp for temp in items if 'ifc2x3.ifcbooleanclippingresult' in typeof(temp)]) + elif reptype.lower() == 'advancedsweptsolid': + count = sizeof([temp for temp in items if ('ifc2x3.ifcsurfacecurvesweptareasolid' in typeof(temp)) or ('ifc2x3.ifcsweptdisksolid' in typeof(temp))]) + elif reptype.lower() == 'brep': + count = sizeof([temp for temp in items if ('ifc2x3.ifcfacetedbrep' in typeof(temp)) or ('ifc2x3.ifcfacetedbrepwithvoids' in typeof(temp))]) + elif reptype.lower() == 'boundingbox': + count = sizeof([temp for temp in items if 'ifc2x3.ifcboundingbox' in typeof(temp)]) + if sizeof(items) > 1: + count = 0 + elif reptype.lower() == 'sectionedspine': + count = sizeof([temp for temp in items if 'ifc2x3.ifcsectionedspine' in typeof(temp)]) + elif reptype.lower() == 'mappedrepresentation': + count = sizeof([temp for temp in items if 'ifc2x3.ifcmappeditem' in typeof(temp)]) + else: + return None + return count == sizeof(items) + + +def IfcTopologyRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'vertex': + count = sizeof([temp for temp in items if 'ifc2x3.ifcvertex' in typeof(temp)]) + elif reptype.lower() == 'edge': + count = sizeof([temp for temp in items if 'ifc2x3.ifcedge' in typeof(temp)]) + elif reptype.lower() == 'path': + count = sizeof([temp for temp in items if 'ifc2x3.ifcpath' in typeof(temp)]) + elif reptype.lower() == 'face': + count = sizeof([temp for temp in items if 'ifc2x3.ifcface' in typeof(temp)]) + elif reptype.lower() == 'shell': + count = sizeof([temp for temp in items if ('ifc2x3.ifcopenshell' in typeof(temp)) or ('ifc2x3.ifcclosedshell' in typeof(temp))]) + elif reptype.lower() == 'undefined': + return True + else: + return None + return count == sizeof(items) + + +def IfcUniquePropertyName(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcValidCalendarDate(date): + + if not 1 <= date.DayComponent <= 31: + return False + if date.MonthComponent == 4: + return 1 <= date.DayComponent <= 30 + elif date.MonthComponent == 6: + return 1 <= date.DayComponent <= 30 + elif date.MonthComponent == 9: + return 1 <= date.DayComponent <= 30 + elif date.MonthComponent == 11: + return 1 <= date.DayComponent <= 30 + elif date.MonthComponent == 2: + if IfcLeapYear(date.YearComponent): + return 1 <= date.DayComponent <= 29 + else: + return 1 <= date.DayComponent <= 28 + else: + return True + + +def IfcValidTime(time): + + if exists(time.SecondComponent): + return exists(time.MinuteComponent) + else: + return True + + +def IfcVectorDifference(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc2x3.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc2x3.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) - (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + +def IfcVectorSum(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc2x3.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc2x3.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) + (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + diff --git a/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4.py b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4.py new file mode 100644 index 0000000000..bdb8a0a53f --- /dev/null +++ b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4.py @@ -0,0 +1,21558 @@ +import ifcopenshell + +def exists(v): + if callable(v): + try: return v() is not None + except IndexError as e: return False + else: return v is not None + + + +def nvl(v, default): return v if v is not None else default + + +sizeof = len +hiindex = len +blength = len +loindex = lambda x: 1 +from math import * +unknown = 'UNKNOWN' + +def usedin(inst, ref_name): + if inst is None: + return [] + _, __, attr = ref_name.split('.') + def filter(): + for ref, attr_idx in inst.wrapped_data.file.get_inverse(inst, allow_duplicate=True, with_attribute_indices=True): + if ref.wrapped_data.get_attribute_names()[attr_idx].lower() == attr: + yield ref + return list(filter()) + + +class express_set(set): + def __rmul__(self, other): + return express_set(set(other) & self) + def __add__(self, other): + def make_list(v): + # Comply with 12.6.3 Union operator + if isinstance(v, (list, tuple, set, express_set)): + return list(v) + else: + return [v] + return express_set(list(self) + make_list(other)) + __radd__ = __add__ + def __repr__(self): + return repr(set(self)) + + +def typeof(inst): + if not inst: + # If V evaluates to indeterminate (?), an empty set is returned. + return express_set([]) + schema_name = inst.is_a(True).split('.')[0].lower() + def inner(): + decl = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(inst.is_a()) + while decl: + yield '.'.join((schema_name, decl.name().lower())) + decl = decl.supertype() + return express_set(inner()) + +class enum_namespace: + def __getattr__(self, k): + return k.upper() + + +IfcActionRequestTypeEnum = enum_namespace() + + +email = IfcActionRequestTypeEnum.EMAIL + + +fax = IfcActionRequestTypeEnum.FAX + + +phone = IfcActionRequestTypeEnum.PHONE + + +post = IfcActionRequestTypeEnum.POST + + +verbal = IfcActionRequestTypeEnum.VERBAL + + +userdefined = IfcActionRequestTypeEnum.USERDEFINED + + +notdefined = IfcActionRequestTypeEnum.NOTDEFINED + + +IfcActionSourceTypeEnum = enum_namespace() + + +dead_load_g = IfcActionSourceTypeEnum.DEAD_LOAD_G + + +completion_g1 = IfcActionSourceTypeEnum.COMPLETION_G1 + + +live_load_q = IfcActionSourceTypeEnum.LIVE_LOAD_Q + + +snow_s = IfcActionSourceTypeEnum.SNOW_S + + +wind_w = IfcActionSourceTypeEnum.WIND_W + + +prestressing_p = IfcActionSourceTypeEnum.PRESTRESSING_P + + +settlement_u = IfcActionSourceTypeEnum.SETTLEMENT_U + + +temperature_t = IfcActionSourceTypeEnum.TEMPERATURE_T + + +earthquake_e = IfcActionSourceTypeEnum.EARTHQUAKE_E + + +fire = IfcActionSourceTypeEnum.FIRE + + +impulse = IfcActionSourceTypeEnum.IMPULSE + + +impact = IfcActionSourceTypeEnum.IMPACT + + +transport = IfcActionSourceTypeEnum.TRANSPORT + + +erection = IfcActionSourceTypeEnum.ERECTION + + +propping = IfcActionSourceTypeEnum.PROPPING + + +system_imperfection = IfcActionSourceTypeEnum.SYSTEM_IMPERFECTION + + +shrinkage = IfcActionSourceTypeEnum.SHRINKAGE + + +creep = IfcActionSourceTypeEnum.CREEP + + +lack_of_fit = IfcActionSourceTypeEnum.LACK_OF_FIT + + +buoyancy = IfcActionSourceTypeEnum.BUOYANCY + + +ice = IfcActionSourceTypeEnum.ICE + + +current = IfcActionSourceTypeEnum.CURRENT + + +wave = IfcActionSourceTypeEnum.WAVE + + +rain = IfcActionSourceTypeEnum.RAIN + + +brakes = IfcActionSourceTypeEnum.BRAKES + + +userdefined = IfcActionSourceTypeEnum.USERDEFINED + + +notdefined = IfcActionSourceTypeEnum.NOTDEFINED + + +IfcActionTypeEnum = enum_namespace() + + +permanent_g = IfcActionTypeEnum.PERMANENT_G + + +variable_q = IfcActionTypeEnum.VARIABLE_Q + + +extraordinary_a = IfcActionTypeEnum.EXTRAORDINARY_A + + +userdefined = IfcActionTypeEnum.USERDEFINED + + +notdefined = IfcActionTypeEnum.NOTDEFINED + + +IfcActuatorTypeEnum = enum_namespace() + + +electricactuator = IfcActuatorTypeEnum.ELECTRICACTUATOR + + +handoperatedactuator = IfcActuatorTypeEnum.HANDOPERATEDACTUATOR + + +hydraulicactuator = IfcActuatorTypeEnum.HYDRAULICACTUATOR + + +pneumaticactuator = IfcActuatorTypeEnum.PNEUMATICACTUATOR + + +thermostaticactuator = IfcActuatorTypeEnum.THERMOSTATICACTUATOR + + +userdefined = IfcActuatorTypeEnum.USERDEFINED + + +notdefined = IfcActuatorTypeEnum.NOTDEFINED + + +IfcAddressTypeEnum = enum_namespace() + + +office = IfcAddressTypeEnum.OFFICE + + +site = IfcAddressTypeEnum.SITE + + +home = IfcAddressTypeEnum.HOME + + +distributionpoint = IfcAddressTypeEnum.DISTRIBUTIONPOINT + + +userdefined = IfcAddressTypeEnum.USERDEFINED + + +IfcAirTerminalBoxTypeEnum = enum_namespace() + + +constantflow = IfcAirTerminalBoxTypeEnum.CONSTANTFLOW + + +variableflowpressuredependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREDEPENDANT + + +variableflowpressureindependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREINDEPENDANT + + +userdefined = IfcAirTerminalBoxTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalBoxTypeEnum.NOTDEFINED + + +IfcAirTerminalTypeEnum = enum_namespace() + + +diffuser = IfcAirTerminalTypeEnum.DIFFUSER + + +grille = IfcAirTerminalTypeEnum.GRILLE + + +louvre = IfcAirTerminalTypeEnum.LOUVRE + + +register = IfcAirTerminalTypeEnum.REGISTER + + +userdefined = IfcAirTerminalTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalTypeEnum.NOTDEFINED + + +IfcAirToAirHeatRecoveryTypeEnum = enum_namespace() + + +fixedplatecounterflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECOUNTERFLOWEXCHANGER + + +fixedplatecrossflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECROSSFLOWEXCHANGER + + +fixedplateparallelflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATEPARALLELFLOWEXCHANGER + + +rotarywheel = IfcAirToAirHeatRecoveryTypeEnum.ROTARYWHEEL + + +runaroundcoilloop = IfcAirToAirHeatRecoveryTypeEnum.RUNAROUNDCOILLOOP + + +heatpipe = IfcAirToAirHeatRecoveryTypeEnum.HEATPIPE + + +twintowerenthalpyrecoveryloops = IfcAirToAirHeatRecoveryTypeEnum.TWINTOWERENTHALPYRECOVERYLOOPS + + +thermosiphonsealedtubeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONSEALEDTUBEHEATEXCHANGERS + + +thermosiphoncoiltypeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONCOILTYPEHEATEXCHANGERS + + +userdefined = IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED + + +notdefined = IfcAirToAirHeatRecoveryTypeEnum.NOTDEFINED + + +IfcAlarmTypeEnum = enum_namespace() + + +bell = IfcAlarmTypeEnum.BELL + + +breakglassbutton = IfcAlarmTypeEnum.BREAKGLASSBUTTON + + +light = IfcAlarmTypeEnum.LIGHT + + +manualpullbox = IfcAlarmTypeEnum.MANUALPULLBOX + + +siren = IfcAlarmTypeEnum.SIREN + + +whistle = IfcAlarmTypeEnum.WHISTLE + + +userdefined = IfcAlarmTypeEnum.USERDEFINED + + +notdefined = IfcAlarmTypeEnum.NOTDEFINED + + +IfcAnalysisModelTypeEnum = enum_namespace() + + +in_plane_loading_2d = IfcAnalysisModelTypeEnum.IN_PLANE_LOADING_2D + + +out_plane_loading_2d = IfcAnalysisModelTypeEnum.OUT_PLANE_LOADING_2D + + +loading_3d = IfcAnalysisModelTypeEnum.LOADING_3D + + +userdefined = IfcAnalysisModelTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisModelTypeEnum.NOTDEFINED + + +IfcAnalysisTheoryTypeEnum = enum_namespace() + + +first_order_theory = IfcAnalysisTheoryTypeEnum.FIRST_ORDER_THEORY + + +second_order_theory = IfcAnalysisTheoryTypeEnum.SECOND_ORDER_THEORY + + +third_order_theory = IfcAnalysisTheoryTypeEnum.THIRD_ORDER_THEORY + + +full_nonlinear_theory = IfcAnalysisTheoryTypeEnum.FULL_NONLINEAR_THEORY + + +userdefined = IfcAnalysisTheoryTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisTheoryTypeEnum.NOTDEFINED + + +IfcArithmeticOperatorEnum = enum_namespace() + + +add = IfcArithmeticOperatorEnum.ADD + + +divide = IfcArithmeticOperatorEnum.DIVIDE + + +multiply = IfcArithmeticOperatorEnum.MULTIPLY + + +subtract = IfcArithmeticOperatorEnum.SUBTRACT + + +IfcAssemblyPlaceEnum = enum_namespace() + + +site = IfcAssemblyPlaceEnum.SITE + + +factory = IfcAssemblyPlaceEnum.FACTORY + + +notdefined = IfcAssemblyPlaceEnum.NOTDEFINED + + +IfcAudioVisualApplianceTypeEnum = enum_namespace() + + +amplifier = IfcAudioVisualApplianceTypeEnum.AMPLIFIER + + +camera = IfcAudioVisualApplianceTypeEnum.CAMERA + + +display = IfcAudioVisualApplianceTypeEnum.DISPLAY + + +microphone = IfcAudioVisualApplianceTypeEnum.MICROPHONE + + +player = IfcAudioVisualApplianceTypeEnum.PLAYER + + +projector = IfcAudioVisualApplianceTypeEnum.PROJECTOR + + +receiver = IfcAudioVisualApplianceTypeEnum.RECEIVER + + +speaker = IfcAudioVisualApplianceTypeEnum.SPEAKER + + +switcher = IfcAudioVisualApplianceTypeEnum.SWITCHER + + +telephone = IfcAudioVisualApplianceTypeEnum.TELEPHONE + + +tuner = IfcAudioVisualApplianceTypeEnum.TUNER + + +userdefined = IfcAudioVisualApplianceTypeEnum.USERDEFINED + + +notdefined = IfcAudioVisualApplianceTypeEnum.NOTDEFINED + + +IfcBSplineCurveForm = enum_namespace() + + +polyline_form = IfcBSplineCurveForm.POLYLINE_FORM + + +circular_arc = IfcBSplineCurveForm.CIRCULAR_ARC + + +elliptic_arc = IfcBSplineCurveForm.ELLIPTIC_ARC + + +parabolic_arc = IfcBSplineCurveForm.PARABOLIC_ARC + + +hyperbolic_arc = IfcBSplineCurveForm.HYPERBOLIC_ARC + + +unspecified = IfcBSplineCurveForm.UNSPECIFIED + + +IfcBSplineSurfaceForm = enum_namespace() + + +plane_surf = IfcBSplineSurfaceForm.PLANE_SURF + + +cylindrical_surf = IfcBSplineSurfaceForm.CYLINDRICAL_SURF + + +conical_surf = IfcBSplineSurfaceForm.CONICAL_SURF + + +spherical_surf = IfcBSplineSurfaceForm.SPHERICAL_SURF + + +toroidal_surf = IfcBSplineSurfaceForm.TOROIDAL_SURF + + +surf_of_revolution = IfcBSplineSurfaceForm.SURF_OF_REVOLUTION + + +ruled_surf = IfcBSplineSurfaceForm.RULED_SURF + + +generalised_cone = IfcBSplineSurfaceForm.GENERALISED_CONE + + +quadric_surf = IfcBSplineSurfaceForm.QUADRIC_SURF + + +surf_of_linear_extrusion = IfcBSplineSurfaceForm.SURF_OF_LINEAR_EXTRUSION + + +unspecified = IfcBSplineSurfaceForm.UNSPECIFIED + + +IfcBeamTypeEnum = enum_namespace() + + +beam = IfcBeamTypeEnum.BEAM + + +joist = IfcBeamTypeEnum.JOIST + + +hollowcore = IfcBeamTypeEnum.HOLLOWCORE + + +lintel = IfcBeamTypeEnum.LINTEL + + +spandrel = IfcBeamTypeEnum.SPANDREL + + +t_beam = IfcBeamTypeEnum.T_BEAM + + +userdefined = IfcBeamTypeEnum.USERDEFINED + + +notdefined = IfcBeamTypeEnum.NOTDEFINED + + +IfcBenchmarkEnum = enum_namespace() + + +greaterthan = IfcBenchmarkEnum.GREATERTHAN + + +greaterthanorequalto = IfcBenchmarkEnum.GREATERTHANOREQUALTO + + +lessthan = IfcBenchmarkEnum.LESSTHAN + + +lessthanorequalto = IfcBenchmarkEnum.LESSTHANOREQUALTO + + +equalto = IfcBenchmarkEnum.EQUALTO + + +notequalto = IfcBenchmarkEnum.NOTEQUALTO + + +includes = IfcBenchmarkEnum.INCLUDES + + +notincludes = IfcBenchmarkEnum.NOTINCLUDES + + +includedin = IfcBenchmarkEnum.INCLUDEDIN + + +notincludedin = IfcBenchmarkEnum.NOTINCLUDEDIN + + +IfcBoilerTypeEnum = enum_namespace() + + +water = IfcBoilerTypeEnum.WATER + + +steam = IfcBoilerTypeEnum.STEAM + + +userdefined = IfcBoilerTypeEnum.USERDEFINED + + +notdefined = IfcBoilerTypeEnum.NOTDEFINED + + +IfcBooleanOperator = enum_namespace() + + +union = IfcBooleanOperator.UNION + + +intersection = IfcBooleanOperator.INTERSECTION + + +difference = IfcBooleanOperator.DIFFERENCE + + +IfcBuildingElementPartTypeEnum = enum_namespace() + + +insulation = IfcBuildingElementPartTypeEnum.INSULATION + + +precastpanel = IfcBuildingElementPartTypeEnum.PRECASTPANEL + + +userdefined = IfcBuildingElementPartTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementPartTypeEnum.NOTDEFINED + + +IfcBuildingElementProxyTypeEnum = enum_namespace() + + +complex = IfcBuildingElementProxyTypeEnum.COMPLEX + + +element = IfcBuildingElementProxyTypeEnum.ELEMENT + + +partial = IfcBuildingElementProxyTypeEnum.PARTIAL + + +provisionforvoid = IfcBuildingElementProxyTypeEnum.PROVISIONFORVOID + + +provisionforspace = IfcBuildingElementProxyTypeEnum.PROVISIONFORSPACE + + +userdefined = IfcBuildingElementProxyTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementProxyTypeEnum.NOTDEFINED + + +IfcBuildingSystemTypeEnum = enum_namespace() + + +fenestration = IfcBuildingSystemTypeEnum.FENESTRATION + + +foundation = IfcBuildingSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuildingSystemTypeEnum.LOADBEARING + + +outershell = IfcBuildingSystemTypeEnum.OUTERSHELL + + +shading = IfcBuildingSystemTypeEnum.SHADING + + +transport = IfcBuildingSystemTypeEnum.TRANSPORT + + +userdefined = IfcBuildingSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuildingSystemTypeEnum.NOTDEFINED + + +IfcBurnerTypeEnum = enum_namespace() + + +userdefined = IfcBurnerTypeEnum.USERDEFINED + + +notdefined = IfcBurnerTypeEnum.NOTDEFINED + + +IfcCableCarrierFittingTypeEnum = enum_namespace() + + +bend = IfcCableCarrierFittingTypeEnum.BEND + + +cross = IfcCableCarrierFittingTypeEnum.CROSS + + +reducer = IfcCableCarrierFittingTypeEnum.REDUCER + + +tee = IfcCableCarrierFittingTypeEnum.TEE + + +userdefined = IfcCableCarrierFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierFittingTypeEnum.NOTDEFINED + + +IfcCableCarrierSegmentTypeEnum = enum_namespace() + + +cableladdersegment = IfcCableCarrierSegmentTypeEnum.CABLELADDERSEGMENT + + +cabletraysegment = IfcCableCarrierSegmentTypeEnum.CABLETRAYSEGMENT + + +cabletrunkingsegment = IfcCableCarrierSegmentTypeEnum.CABLETRUNKINGSEGMENT + + +conduitsegment = IfcCableCarrierSegmentTypeEnum.CONDUITSEGMENT + + +userdefined = IfcCableCarrierSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierSegmentTypeEnum.NOTDEFINED + + +IfcCableFittingTypeEnum = enum_namespace() + + +connector = IfcCableFittingTypeEnum.CONNECTOR + + +entry = IfcCableFittingTypeEnum.ENTRY + + +exit = IfcCableFittingTypeEnum.EXIT + + +junction = IfcCableFittingTypeEnum.JUNCTION + + +transition = IfcCableFittingTypeEnum.TRANSITION + + +userdefined = IfcCableFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableFittingTypeEnum.NOTDEFINED + + +IfcCableSegmentTypeEnum = enum_namespace() + + +busbarsegment = IfcCableSegmentTypeEnum.BUSBARSEGMENT + + +cablesegment = IfcCableSegmentTypeEnum.CABLESEGMENT + + +conductorsegment = IfcCableSegmentTypeEnum.CONDUCTORSEGMENT + + +coresegment = IfcCableSegmentTypeEnum.CORESEGMENT + + +userdefined = IfcCableSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableSegmentTypeEnum.NOTDEFINED + + +IfcChangeActionEnum = enum_namespace() + + +nochange = IfcChangeActionEnum.NOCHANGE + + +modified = IfcChangeActionEnum.MODIFIED + + +added = IfcChangeActionEnum.ADDED + + +deleted = IfcChangeActionEnum.DELETED + + +notdefined = IfcChangeActionEnum.NOTDEFINED + + +IfcChillerTypeEnum = enum_namespace() + + +aircooled = IfcChillerTypeEnum.AIRCOOLED + + +watercooled = IfcChillerTypeEnum.WATERCOOLED + + +heatrecovery = IfcChillerTypeEnum.HEATRECOVERY + + +userdefined = IfcChillerTypeEnum.USERDEFINED + + +notdefined = IfcChillerTypeEnum.NOTDEFINED + + +IfcChimneyTypeEnum = enum_namespace() + + +userdefined = IfcChimneyTypeEnum.USERDEFINED + + +notdefined = IfcChimneyTypeEnum.NOTDEFINED + + +IfcCoilTypeEnum = enum_namespace() + + +dxcoolingcoil = IfcCoilTypeEnum.DXCOOLINGCOIL + + +electricheatingcoil = IfcCoilTypeEnum.ELECTRICHEATINGCOIL + + +gasheatingcoil = IfcCoilTypeEnum.GASHEATINGCOIL + + +hydroniccoil = IfcCoilTypeEnum.HYDRONICCOIL + + +steamheatingcoil = IfcCoilTypeEnum.STEAMHEATINGCOIL + + +watercoolingcoil = IfcCoilTypeEnum.WATERCOOLINGCOIL + + +waterheatingcoil = IfcCoilTypeEnum.WATERHEATINGCOIL + + +userdefined = IfcCoilTypeEnum.USERDEFINED + + +notdefined = IfcCoilTypeEnum.NOTDEFINED + + +IfcColumnTypeEnum = enum_namespace() + + +column = IfcColumnTypeEnum.COLUMN + + +pilaster = IfcColumnTypeEnum.PILASTER + + +userdefined = IfcColumnTypeEnum.USERDEFINED + + +notdefined = IfcColumnTypeEnum.NOTDEFINED + + +IfcCommunicationsApplianceTypeEnum = enum_namespace() + + +antenna = IfcCommunicationsApplianceTypeEnum.ANTENNA + + +computer = IfcCommunicationsApplianceTypeEnum.COMPUTER + + +fax = IfcCommunicationsApplianceTypeEnum.FAX + + +gateway = IfcCommunicationsApplianceTypeEnum.GATEWAY + + +modem = IfcCommunicationsApplianceTypeEnum.MODEM + + +networkappliance = IfcCommunicationsApplianceTypeEnum.NETWORKAPPLIANCE + + +networkbridge = IfcCommunicationsApplianceTypeEnum.NETWORKBRIDGE + + +networkhub = IfcCommunicationsApplianceTypeEnum.NETWORKHUB + + +printer = IfcCommunicationsApplianceTypeEnum.PRINTER + + +repeater = IfcCommunicationsApplianceTypeEnum.REPEATER + + +router = IfcCommunicationsApplianceTypeEnum.ROUTER + + +scanner = IfcCommunicationsApplianceTypeEnum.SCANNER + + +userdefined = IfcCommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcCommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcComplexPropertyTemplateTypeEnum = enum_namespace() + + +p_complex = IfcComplexPropertyTemplateTypeEnum.P_COMPLEX + + +q_complex = IfcComplexPropertyTemplateTypeEnum.Q_COMPLEX + + +IfcCompressorTypeEnum = enum_namespace() + + +dynamic = IfcCompressorTypeEnum.DYNAMIC + + +reciprocating = IfcCompressorTypeEnum.RECIPROCATING + + +rotary = IfcCompressorTypeEnum.ROTARY + + +scroll = IfcCompressorTypeEnum.SCROLL + + +trochoidal = IfcCompressorTypeEnum.TROCHOIDAL + + +singlestage = IfcCompressorTypeEnum.SINGLESTAGE + + +booster = IfcCompressorTypeEnum.BOOSTER + + +opentype = IfcCompressorTypeEnum.OPENTYPE + + +hermetic = IfcCompressorTypeEnum.HERMETIC + + +semihermetic = IfcCompressorTypeEnum.SEMIHERMETIC + + +weldedshellhermetic = IfcCompressorTypeEnum.WELDEDSHELLHERMETIC + + +rollingpiston = IfcCompressorTypeEnum.ROLLINGPISTON + + +rotaryvane = IfcCompressorTypeEnum.ROTARYVANE + + +singlescrew = IfcCompressorTypeEnum.SINGLESCREW + + +twinscrew = IfcCompressorTypeEnum.TWINSCREW + + +userdefined = IfcCompressorTypeEnum.USERDEFINED + + +notdefined = IfcCompressorTypeEnum.NOTDEFINED + + +IfcCondenserTypeEnum = enum_namespace() + + +aircooled = IfcCondenserTypeEnum.AIRCOOLED + + +evaporativecooled = IfcCondenserTypeEnum.EVAPORATIVECOOLED + + +watercooled = IfcCondenserTypeEnum.WATERCOOLED + + +watercooledbrazedplate = IfcCondenserTypeEnum.WATERCOOLEDBRAZEDPLATE + + +watercooledshellcoil = IfcCondenserTypeEnum.WATERCOOLEDSHELLCOIL + + +watercooledshelltube = IfcCondenserTypeEnum.WATERCOOLEDSHELLTUBE + + +watercooledtubeintube = IfcCondenserTypeEnum.WATERCOOLEDTUBEINTUBE + + +userdefined = IfcCondenserTypeEnum.USERDEFINED + + +notdefined = IfcCondenserTypeEnum.NOTDEFINED + + +IfcConnectionTypeEnum = enum_namespace() + + +atpath = IfcConnectionTypeEnum.ATPATH + + +atstart = IfcConnectionTypeEnum.ATSTART + + +atend = IfcConnectionTypeEnum.ATEND + + +notdefined = IfcConnectionTypeEnum.NOTDEFINED + + +IfcConstraintEnum = enum_namespace() + + +hard = IfcConstraintEnum.HARD + + +soft = IfcConstraintEnum.SOFT + + +advisory = IfcConstraintEnum.ADVISORY + + +userdefined = IfcConstraintEnum.USERDEFINED + + +notdefined = IfcConstraintEnum.NOTDEFINED + + +IfcConstructionEquipmentResourceTypeEnum = enum_namespace() + + +demolishing = IfcConstructionEquipmentResourceTypeEnum.DEMOLISHING + + +earthmoving = IfcConstructionEquipmentResourceTypeEnum.EARTHMOVING + + +erecting = IfcConstructionEquipmentResourceTypeEnum.ERECTING + + +heating = IfcConstructionEquipmentResourceTypeEnum.HEATING + + +lighting = IfcConstructionEquipmentResourceTypeEnum.LIGHTING + + +paving = IfcConstructionEquipmentResourceTypeEnum.PAVING + + +pumping = IfcConstructionEquipmentResourceTypeEnum.PUMPING + + +transporting = IfcConstructionEquipmentResourceTypeEnum.TRANSPORTING + + +userdefined = IfcConstructionEquipmentResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionEquipmentResourceTypeEnum.NOTDEFINED + + +IfcConstructionMaterialResourceTypeEnum = enum_namespace() + + +aggregates = IfcConstructionMaterialResourceTypeEnum.AGGREGATES + + +concrete = IfcConstructionMaterialResourceTypeEnum.CONCRETE + + +drywall = IfcConstructionMaterialResourceTypeEnum.DRYWALL + + +fuel = IfcConstructionMaterialResourceTypeEnum.FUEL + + +gypsum = IfcConstructionMaterialResourceTypeEnum.GYPSUM + + +masonry = IfcConstructionMaterialResourceTypeEnum.MASONRY + + +metal = IfcConstructionMaterialResourceTypeEnum.METAL + + +plastic = IfcConstructionMaterialResourceTypeEnum.PLASTIC + + +wood = IfcConstructionMaterialResourceTypeEnum.WOOD + + +notdefined = IfcConstructionMaterialResourceTypeEnum.NOTDEFINED + + +userdefined = IfcConstructionMaterialResourceTypeEnum.USERDEFINED + + +IfcConstructionProductResourceTypeEnum = enum_namespace() + + +assembly = IfcConstructionProductResourceTypeEnum.ASSEMBLY + + +formwork = IfcConstructionProductResourceTypeEnum.FORMWORK + + +userdefined = IfcConstructionProductResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionProductResourceTypeEnum.NOTDEFINED + + +IfcControllerTypeEnum = enum_namespace() + + +floating = IfcControllerTypeEnum.FLOATING + + +programmable = IfcControllerTypeEnum.PROGRAMMABLE + + +proportional = IfcControllerTypeEnum.PROPORTIONAL + + +multiposition = IfcControllerTypeEnum.MULTIPOSITION + + +twoposition = IfcControllerTypeEnum.TWOPOSITION + + +userdefined = IfcControllerTypeEnum.USERDEFINED + + +notdefined = IfcControllerTypeEnum.NOTDEFINED + + +IfcCooledBeamTypeEnum = enum_namespace() + + +active = IfcCooledBeamTypeEnum.ACTIVE + + +passive = IfcCooledBeamTypeEnum.PASSIVE + + +userdefined = IfcCooledBeamTypeEnum.USERDEFINED + + +notdefined = IfcCooledBeamTypeEnum.NOTDEFINED + + +IfcCoolingTowerTypeEnum = enum_namespace() + + +naturaldraft = IfcCoolingTowerTypeEnum.NATURALDRAFT + + +mechanicalinduceddraft = IfcCoolingTowerTypeEnum.MECHANICALINDUCEDDRAFT + + +mechanicalforceddraft = IfcCoolingTowerTypeEnum.MECHANICALFORCEDDRAFT + + +userdefined = IfcCoolingTowerTypeEnum.USERDEFINED + + +notdefined = IfcCoolingTowerTypeEnum.NOTDEFINED + + +IfcCostItemTypeEnum = enum_namespace() + + +userdefined = IfcCostItemTypeEnum.USERDEFINED + + +notdefined = IfcCostItemTypeEnum.NOTDEFINED + + +IfcCostScheduleTypeEnum = enum_namespace() + + +budget = IfcCostScheduleTypeEnum.BUDGET + + +costplan = IfcCostScheduleTypeEnum.COSTPLAN + + +estimate = IfcCostScheduleTypeEnum.ESTIMATE + + +tender = IfcCostScheduleTypeEnum.TENDER + + +pricedbillofquantities = IfcCostScheduleTypeEnum.PRICEDBILLOFQUANTITIES + + +unpricedbillofquantities = IfcCostScheduleTypeEnum.UNPRICEDBILLOFQUANTITIES + + +scheduleofrates = IfcCostScheduleTypeEnum.SCHEDULEOFRATES + + +userdefined = IfcCostScheduleTypeEnum.USERDEFINED + + +notdefined = IfcCostScheduleTypeEnum.NOTDEFINED + + +IfcCoveringTypeEnum = enum_namespace() + + +ceiling = IfcCoveringTypeEnum.CEILING + + +flooring = IfcCoveringTypeEnum.FLOORING + + +cladding = IfcCoveringTypeEnum.CLADDING + + +roofing = IfcCoveringTypeEnum.ROOFING + + +molding = IfcCoveringTypeEnum.MOLDING + + +skirtingboard = IfcCoveringTypeEnum.SKIRTINGBOARD + + +insulation = IfcCoveringTypeEnum.INSULATION + + +membrane = IfcCoveringTypeEnum.MEMBRANE + + +sleeving = IfcCoveringTypeEnum.SLEEVING + + +wrapping = IfcCoveringTypeEnum.WRAPPING + + +userdefined = IfcCoveringTypeEnum.USERDEFINED + + +notdefined = IfcCoveringTypeEnum.NOTDEFINED + + +IfcCrewResourceTypeEnum = enum_namespace() + + +office = IfcCrewResourceTypeEnum.OFFICE + + +site = IfcCrewResourceTypeEnum.SITE + + +userdefined = IfcCrewResourceTypeEnum.USERDEFINED + + +notdefined = IfcCrewResourceTypeEnum.NOTDEFINED + + +IfcCurtainWallTypeEnum = enum_namespace() + + +userdefined = IfcCurtainWallTypeEnum.USERDEFINED + + +notdefined = IfcCurtainWallTypeEnum.NOTDEFINED + + +IfcCurveInterpolationEnum = enum_namespace() + + +linear = IfcCurveInterpolationEnum.LINEAR + + +log_linear = IfcCurveInterpolationEnum.LOG_LINEAR + + +log_log = IfcCurveInterpolationEnum.LOG_LOG + + +notdefined = IfcCurveInterpolationEnum.NOTDEFINED + + +IfcDamperTypeEnum = enum_namespace() + + +backdraftdamper = IfcDamperTypeEnum.BACKDRAFTDAMPER + + +balancingdamper = IfcDamperTypeEnum.BALANCINGDAMPER + + +blastdamper = IfcDamperTypeEnum.BLASTDAMPER + + +controldamper = IfcDamperTypeEnum.CONTROLDAMPER + + +firedamper = IfcDamperTypeEnum.FIREDAMPER + + +firesmokedamper = IfcDamperTypeEnum.FIRESMOKEDAMPER + + +fumehoodexhaust = IfcDamperTypeEnum.FUMEHOODEXHAUST + + +gravitydamper = IfcDamperTypeEnum.GRAVITYDAMPER + + +gravityreliefdamper = IfcDamperTypeEnum.GRAVITYRELIEFDAMPER + + +reliefdamper = IfcDamperTypeEnum.RELIEFDAMPER + + +smokedamper = IfcDamperTypeEnum.SMOKEDAMPER + + +userdefined = IfcDamperTypeEnum.USERDEFINED + + +notdefined = IfcDamperTypeEnum.NOTDEFINED + + +IfcDataOriginEnum = enum_namespace() + + +measured = IfcDataOriginEnum.MEASURED + + +predicted = IfcDataOriginEnum.PREDICTED + + +simulated = IfcDataOriginEnum.SIMULATED + + +userdefined = IfcDataOriginEnum.USERDEFINED + + +notdefined = IfcDataOriginEnum.NOTDEFINED + + +IfcDerivedUnitEnum = enum_namespace() + + +angularvelocityunit = IfcDerivedUnitEnum.ANGULARVELOCITYUNIT + + +areadensityunit = IfcDerivedUnitEnum.AREADENSITYUNIT + + +compoundplaneangleunit = IfcDerivedUnitEnum.COMPOUNDPLANEANGLEUNIT + + +dynamicviscosityunit = IfcDerivedUnitEnum.DYNAMICVISCOSITYUNIT + + +heatfluxdensityunit = IfcDerivedUnitEnum.HEATFLUXDENSITYUNIT + + +integercountrateunit = IfcDerivedUnitEnum.INTEGERCOUNTRATEUNIT + + +isothermalmoisturecapacityunit = IfcDerivedUnitEnum.ISOTHERMALMOISTURECAPACITYUNIT + + +kinematicviscosityunit = IfcDerivedUnitEnum.KINEMATICVISCOSITYUNIT + + +linearvelocityunit = IfcDerivedUnitEnum.LINEARVELOCITYUNIT + + +massdensityunit = IfcDerivedUnitEnum.MASSDENSITYUNIT + + +massflowrateunit = IfcDerivedUnitEnum.MASSFLOWRATEUNIT + + +moisturediffusivityunit = IfcDerivedUnitEnum.MOISTUREDIFFUSIVITYUNIT + + +molecularweightunit = IfcDerivedUnitEnum.MOLECULARWEIGHTUNIT + + +specificheatcapacityunit = IfcDerivedUnitEnum.SPECIFICHEATCAPACITYUNIT + + +thermaladmittanceunit = IfcDerivedUnitEnum.THERMALADMITTANCEUNIT + + +thermalconductanceunit = IfcDerivedUnitEnum.THERMALCONDUCTANCEUNIT + + +thermalresistanceunit = IfcDerivedUnitEnum.THERMALRESISTANCEUNIT + + +thermaltransmittanceunit = IfcDerivedUnitEnum.THERMALTRANSMITTANCEUNIT + + +vaporpermeabilityunit = IfcDerivedUnitEnum.VAPORPERMEABILITYUNIT + + +volumetricflowrateunit = IfcDerivedUnitEnum.VOLUMETRICFLOWRATEUNIT + + +rotationalfrequencyunit = IfcDerivedUnitEnum.ROTATIONALFREQUENCYUNIT + + +torqueunit = IfcDerivedUnitEnum.TORQUEUNIT + + +momentofinertiaunit = IfcDerivedUnitEnum.MOMENTOFINERTIAUNIT + + +linearmomentunit = IfcDerivedUnitEnum.LINEARMOMENTUNIT + + +linearforceunit = IfcDerivedUnitEnum.LINEARFORCEUNIT + + +planarforceunit = IfcDerivedUnitEnum.PLANARFORCEUNIT + + +modulusofelasticityunit = IfcDerivedUnitEnum.MODULUSOFELASTICITYUNIT + + +shearmodulusunit = IfcDerivedUnitEnum.SHEARMODULUSUNIT + + +linearstiffnessunit = IfcDerivedUnitEnum.LINEARSTIFFNESSUNIT + + +rotationalstiffnessunit = IfcDerivedUnitEnum.ROTATIONALSTIFFNESSUNIT + + +modulusofsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFSUBGRADEREACTIONUNIT + + +accelerationunit = IfcDerivedUnitEnum.ACCELERATIONUNIT + + +curvatureunit = IfcDerivedUnitEnum.CURVATUREUNIT + + +heatingvalueunit = IfcDerivedUnitEnum.HEATINGVALUEUNIT + + +ionconcentrationunit = IfcDerivedUnitEnum.IONCONCENTRATIONUNIT + + +luminousintensitydistributionunit = IfcDerivedUnitEnum.LUMINOUSINTENSITYDISTRIBUTIONUNIT + + +massperlengthunit = IfcDerivedUnitEnum.MASSPERLENGTHUNIT + + +modulusoflinearsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFLINEARSUBGRADEREACTIONUNIT + + +modulusofrotationalsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFROTATIONALSUBGRADEREACTIONUNIT + + +phunit = IfcDerivedUnitEnum.PHUNIT + + +rotationalmassunit = IfcDerivedUnitEnum.ROTATIONALMASSUNIT + + +sectionareaintegralunit = IfcDerivedUnitEnum.SECTIONAREAINTEGRALUNIT + + +sectionmodulusunit = IfcDerivedUnitEnum.SECTIONMODULUSUNIT + + +soundpowerlevelunit = IfcDerivedUnitEnum.SOUNDPOWERLEVELUNIT + + +soundpowerunit = IfcDerivedUnitEnum.SOUNDPOWERUNIT + + +soundpressurelevelunit = IfcDerivedUnitEnum.SOUNDPRESSURELEVELUNIT + + +soundpressureunit = IfcDerivedUnitEnum.SOUNDPRESSUREUNIT + + +temperaturegradientunit = IfcDerivedUnitEnum.TEMPERATUREGRADIENTUNIT + + +temperaturerateofchangeunit = IfcDerivedUnitEnum.TEMPERATURERATEOFCHANGEUNIT + + +thermalexpansioncoefficientunit = IfcDerivedUnitEnum.THERMALEXPANSIONCOEFFICIENTUNIT + + +warpingconstantunit = IfcDerivedUnitEnum.WARPINGCONSTANTUNIT + + +warpingmomentunit = IfcDerivedUnitEnum.WARPINGMOMENTUNIT + + +userdefined = IfcDerivedUnitEnum.USERDEFINED + + +IfcDirectionSenseEnum = enum_namespace() + + +positive = IfcDirectionSenseEnum.POSITIVE + + +negative = IfcDirectionSenseEnum.NEGATIVE + + +IfcDiscreteAccessoryTypeEnum = enum_namespace() + + +anchorplate = IfcDiscreteAccessoryTypeEnum.ANCHORPLATE + + +bracket = IfcDiscreteAccessoryTypeEnum.BRACKET + + +shoe = IfcDiscreteAccessoryTypeEnum.SHOE + + +userdefined = IfcDiscreteAccessoryTypeEnum.USERDEFINED + + +notdefined = IfcDiscreteAccessoryTypeEnum.NOTDEFINED + + +IfcDistributionChamberElementTypeEnum = enum_namespace() + + +formedduct = IfcDistributionChamberElementTypeEnum.FORMEDDUCT + + +inspectionchamber = IfcDistributionChamberElementTypeEnum.INSPECTIONCHAMBER + + +inspectionpit = IfcDistributionChamberElementTypeEnum.INSPECTIONPIT + + +manhole = IfcDistributionChamberElementTypeEnum.MANHOLE + + +meterchamber = IfcDistributionChamberElementTypeEnum.METERCHAMBER + + +sump = IfcDistributionChamberElementTypeEnum.SUMP + + +trench = IfcDistributionChamberElementTypeEnum.TRENCH + + +valvechamber = IfcDistributionChamberElementTypeEnum.VALVECHAMBER + + +userdefined = IfcDistributionChamberElementTypeEnum.USERDEFINED + + +notdefined = IfcDistributionChamberElementTypeEnum.NOTDEFINED + + +IfcDistributionPortTypeEnum = enum_namespace() + + +cable = IfcDistributionPortTypeEnum.CABLE + + +cablecarrier = IfcDistributionPortTypeEnum.CABLECARRIER + + +duct = IfcDistributionPortTypeEnum.DUCT + + +pipe = IfcDistributionPortTypeEnum.PIPE + + +userdefined = IfcDistributionPortTypeEnum.USERDEFINED + + +notdefined = IfcDistributionPortTypeEnum.NOTDEFINED + + +IfcDistributionSystemEnum = enum_namespace() + + +airconditioning = IfcDistributionSystemEnum.AIRCONDITIONING + + +audiovisual = IfcDistributionSystemEnum.AUDIOVISUAL + + +chemical = IfcDistributionSystemEnum.CHEMICAL + + +chilledwater = IfcDistributionSystemEnum.CHILLEDWATER + + +communication = IfcDistributionSystemEnum.COMMUNICATION + + +compressedair = IfcDistributionSystemEnum.COMPRESSEDAIR + + +condenserwater = IfcDistributionSystemEnum.CONDENSERWATER + + +control = IfcDistributionSystemEnum.CONTROL + + +conveying = IfcDistributionSystemEnum.CONVEYING + + +data = IfcDistributionSystemEnum.DATA + + +disposal = IfcDistributionSystemEnum.DISPOSAL + + +domesticcoldwater = IfcDistributionSystemEnum.DOMESTICCOLDWATER + + +domestichotwater = IfcDistributionSystemEnum.DOMESTICHOTWATER + + +drainage = IfcDistributionSystemEnum.DRAINAGE + + +earthing = IfcDistributionSystemEnum.EARTHING + + +electrical = IfcDistributionSystemEnum.ELECTRICAL + + +electroacoustic = IfcDistributionSystemEnum.ELECTROACOUSTIC + + +exhaust = IfcDistributionSystemEnum.EXHAUST + + +fireprotection = IfcDistributionSystemEnum.FIREPROTECTION + + +fuel = IfcDistributionSystemEnum.FUEL + + +gas = IfcDistributionSystemEnum.GAS + + +hazardous = IfcDistributionSystemEnum.HAZARDOUS + + +heating = IfcDistributionSystemEnum.HEATING + + +lighting = IfcDistributionSystemEnum.LIGHTING + + +lightningprotection = IfcDistributionSystemEnum.LIGHTNINGPROTECTION + + +municipalsolidwaste = IfcDistributionSystemEnum.MUNICIPALSOLIDWASTE + + +oil = IfcDistributionSystemEnum.OIL + + +operational = IfcDistributionSystemEnum.OPERATIONAL + + +powergeneration = IfcDistributionSystemEnum.POWERGENERATION + + +rainwater = IfcDistributionSystemEnum.RAINWATER + + +refrigeration = IfcDistributionSystemEnum.REFRIGERATION + + +security = IfcDistributionSystemEnum.SECURITY + + +sewage = IfcDistributionSystemEnum.SEWAGE + + +signal = IfcDistributionSystemEnum.SIGNAL + + +stormwater = IfcDistributionSystemEnum.STORMWATER + + +telephone = IfcDistributionSystemEnum.TELEPHONE + + +tv = IfcDistributionSystemEnum.TV + + +vacuum = IfcDistributionSystemEnum.VACUUM + + +vent = IfcDistributionSystemEnum.VENT + + +ventilation = IfcDistributionSystemEnum.VENTILATION + + +wastewater = IfcDistributionSystemEnum.WASTEWATER + + +watersupply = IfcDistributionSystemEnum.WATERSUPPLY + + +userdefined = IfcDistributionSystemEnum.USERDEFINED + + +notdefined = IfcDistributionSystemEnum.NOTDEFINED + + +IfcDocumentConfidentialityEnum = enum_namespace() + + +public = IfcDocumentConfidentialityEnum.PUBLIC + + +restricted = IfcDocumentConfidentialityEnum.RESTRICTED + + +confidential = IfcDocumentConfidentialityEnum.CONFIDENTIAL + + +personal = IfcDocumentConfidentialityEnum.PERSONAL + + +userdefined = IfcDocumentConfidentialityEnum.USERDEFINED + + +notdefined = IfcDocumentConfidentialityEnum.NOTDEFINED + + +IfcDocumentStatusEnum = enum_namespace() + + +draft = IfcDocumentStatusEnum.DRAFT + + +finaldraft = IfcDocumentStatusEnum.FINALDRAFT + + +final = IfcDocumentStatusEnum.FINAL + + +revision = IfcDocumentStatusEnum.REVISION + + +notdefined = IfcDocumentStatusEnum.NOTDEFINED + + +IfcDoorPanelOperationEnum = enum_namespace() + + +swinging = IfcDoorPanelOperationEnum.SWINGING + + +double_acting = IfcDoorPanelOperationEnum.DOUBLE_ACTING + + +sliding = IfcDoorPanelOperationEnum.SLIDING + + +folding = IfcDoorPanelOperationEnum.FOLDING + + +revolving = IfcDoorPanelOperationEnum.REVOLVING + + +rollingup = IfcDoorPanelOperationEnum.ROLLINGUP + + +fixedpanel = IfcDoorPanelOperationEnum.FIXEDPANEL + + +userdefined = IfcDoorPanelOperationEnum.USERDEFINED + + +notdefined = IfcDoorPanelOperationEnum.NOTDEFINED + + +IfcDoorPanelPositionEnum = enum_namespace() + + +left = IfcDoorPanelPositionEnum.LEFT + + +middle = IfcDoorPanelPositionEnum.MIDDLE + + +right = IfcDoorPanelPositionEnum.RIGHT + + +notdefined = IfcDoorPanelPositionEnum.NOTDEFINED + + +IfcDoorStyleConstructionEnum = enum_namespace() + + +aluminium = IfcDoorStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcDoorStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcDoorStyleConstructionEnum.STEEL + + +wood = IfcDoorStyleConstructionEnum.WOOD + + +aluminium_wood = IfcDoorStyleConstructionEnum.ALUMINIUM_WOOD + + +aluminium_plastic = IfcDoorStyleConstructionEnum.ALUMINIUM_PLASTIC + + +plastic = IfcDoorStyleConstructionEnum.PLASTIC + + +userdefined = IfcDoorStyleConstructionEnum.USERDEFINED + + +notdefined = IfcDoorStyleConstructionEnum.NOTDEFINED + + +IfcDoorStyleOperationEnum = enum_namespace() + + +single_swing_left = IfcDoorStyleOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorStyleOperationEnum.SINGLE_SWING_RIGHT + + +double_door_single_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_swing_left = IfcDoorStyleOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorStyleOperationEnum.DOUBLE_SWING_RIGHT + + +double_door_double_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +sliding_to_left = IfcDoorStyleOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorStyleOperationEnum.SLIDING_TO_RIGHT + + +double_door_sliding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SLIDING + + +folding_to_left = IfcDoorStyleOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorStyleOperationEnum.FOLDING_TO_RIGHT + + +double_door_folding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_FOLDING + + +revolving = IfcDoorStyleOperationEnum.REVOLVING + + +rollingup = IfcDoorStyleOperationEnum.ROLLINGUP + + +userdefined = IfcDoorStyleOperationEnum.USERDEFINED + + +notdefined = IfcDoorStyleOperationEnum.NOTDEFINED + + +IfcDoorTypeEnum = enum_namespace() + + +door = IfcDoorTypeEnum.DOOR + + +gate = IfcDoorTypeEnum.GATE + + +trapdoor = IfcDoorTypeEnum.TRAPDOOR + + +userdefined = IfcDoorTypeEnum.USERDEFINED + + +notdefined = IfcDoorTypeEnum.NOTDEFINED + + +IfcDoorTypeOperationEnum = enum_namespace() + + +single_swing_left = IfcDoorTypeOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorTypeOperationEnum.SINGLE_SWING_RIGHT + + +double_door_single_swing = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_swing_left = IfcDoorTypeOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorTypeOperationEnum.DOUBLE_SWING_RIGHT + + +double_door_double_swing = IfcDoorTypeOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +sliding_to_left = IfcDoorTypeOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorTypeOperationEnum.SLIDING_TO_RIGHT + + +double_door_sliding = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SLIDING + + +folding_to_left = IfcDoorTypeOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorTypeOperationEnum.FOLDING_TO_RIGHT + + +double_door_folding = IfcDoorTypeOperationEnum.DOUBLE_DOOR_FOLDING + + +revolving = IfcDoorTypeOperationEnum.REVOLVING + + +rollingup = IfcDoorTypeOperationEnum.ROLLINGUP + + +swing_fixed_left = IfcDoorTypeOperationEnum.SWING_FIXED_LEFT + + +swing_fixed_right = IfcDoorTypeOperationEnum.SWING_FIXED_RIGHT + + +userdefined = IfcDoorTypeOperationEnum.USERDEFINED + + +notdefined = IfcDoorTypeOperationEnum.NOTDEFINED + + +IfcDuctFittingTypeEnum = enum_namespace() + + +bend = IfcDuctFittingTypeEnum.BEND + + +connector = IfcDuctFittingTypeEnum.CONNECTOR + + +entry = IfcDuctFittingTypeEnum.ENTRY + + +exit = IfcDuctFittingTypeEnum.EXIT + + +junction = IfcDuctFittingTypeEnum.JUNCTION + + +obstruction = IfcDuctFittingTypeEnum.OBSTRUCTION + + +transition = IfcDuctFittingTypeEnum.TRANSITION + + +userdefined = IfcDuctFittingTypeEnum.USERDEFINED + + +notdefined = IfcDuctFittingTypeEnum.NOTDEFINED + + +IfcDuctSegmentTypeEnum = enum_namespace() + + +rigidsegment = IfcDuctSegmentTypeEnum.RIGIDSEGMENT + + +flexiblesegment = IfcDuctSegmentTypeEnum.FLEXIBLESEGMENT + + +userdefined = IfcDuctSegmentTypeEnum.USERDEFINED + + +notdefined = IfcDuctSegmentTypeEnum.NOTDEFINED + + +IfcDuctSilencerTypeEnum = enum_namespace() + + +flatoval = IfcDuctSilencerTypeEnum.FLATOVAL + + +rectangular = IfcDuctSilencerTypeEnum.RECTANGULAR + + +round = IfcDuctSilencerTypeEnum.ROUND + + +userdefined = IfcDuctSilencerTypeEnum.USERDEFINED + + +notdefined = IfcDuctSilencerTypeEnum.NOTDEFINED + + +IfcElectricApplianceTypeEnum = enum_namespace() + + +dishwasher = IfcElectricApplianceTypeEnum.DISHWASHER + + +electriccooker = IfcElectricApplianceTypeEnum.ELECTRICCOOKER + + +freestandingelectricheater = IfcElectricApplianceTypeEnum.FREESTANDINGELECTRICHEATER + + +freestandingfan = IfcElectricApplianceTypeEnum.FREESTANDINGFAN + + +freestandingwaterheater = IfcElectricApplianceTypeEnum.FREESTANDINGWATERHEATER + + +freestandingwatercooler = IfcElectricApplianceTypeEnum.FREESTANDINGWATERCOOLER + + +freezer = IfcElectricApplianceTypeEnum.FREEZER + + +fridge_freezer = IfcElectricApplianceTypeEnum.FRIDGE_FREEZER + + +handdryer = IfcElectricApplianceTypeEnum.HANDDRYER + + +kitchenmachine = IfcElectricApplianceTypeEnum.KITCHENMACHINE + + +microwave = IfcElectricApplianceTypeEnum.MICROWAVE + + +photocopier = IfcElectricApplianceTypeEnum.PHOTOCOPIER + + +refrigerator = IfcElectricApplianceTypeEnum.REFRIGERATOR + + +tumbledryer = IfcElectricApplianceTypeEnum.TUMBLEDRYER + + +vendingmachine = IfcElectricApplianceTypeEnum.VENDINGMACHINE + + +washingmachine = IfcElectricApplianceTypeEnum.WASHINGMACHINE + + +userdefined = IfcElectricApplianceTypeEnum.USERDEFINED + + +notdefined = IfcElectricApplianceTypeEnum.NOTDEFINED + + +IfcElectricDistributionBoardTypeEnum = enum_namespace() + + +consumerunit = IfcElectricDistributionBoardTypeEnum.CONSUMERUNIT + + +distributionboard = IfcElectricDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +motorcontrolcentre = IfcElectricDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +switchboard = IfcElectricDistributionBoardTypeEnum.SWITCHBOARD + + +userdefined = IfcElectricDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcElectricDistributionBoardTypeEnum.NOTDEFINED + + +IfcElectricFlowStorageDeviceTypeEnum = enum_namespace() + + +battery = IfcElectricFlowStorageDeviceTypeEnum.BATTERY + + +capacitorbank = IfcElectricFlowStorageDeviceTypeEnum.CAPACITORBANK + + +harmonicfilter = IfcElectricFlowStorageDeviceTypeEnum.HARMONICFILTER + + +inductorbank = IfcElectricFlowStorageDeviceTypeEnum.INDUCTORBANK + + +ups = IfcElectricFlowStorageDeviceTypeEnum.UPS + + +userdefined = IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowStorageDeviceTypeEnum.NOTDEFINED + + +IfcElectricGeneratorTypeEnum = enum_namespace() + + +chp = IfcElectricGeneratorTypeEnum.CHP + + +enginegenerator = IfcElectricGeneratorTypeEnum.ENGINEGENERATOR + + +standalone = IfcElectricGeneratorTypeEnum.STANDALONE + + +userdefined = IfcElectricGeneratorTypeEnum.USERDEFINED + + +notdefined = IfcElectricGeneratorTypeEnum.NOTDEFINED + + +IfcElectricMotorTypeEnum = enum_namespace() + + +dc = IfcElectricMotorTypeEnum.DC + + +induction = IfcElectricMotorTypeEnum.INDUCTION + + +polyphase = IfcElectricMotorTypeEnum.POLYPHASE + + +reluctancesynchronous = IfcElectricMotorTypeEnum.RELUCTANCESYNCHRONOUS + + +synchronous = IfcElectricMotorTypeEnum.SYNCHRONOUS + + +userdefined = IfcElectricMotorTypeEnum.USERDEFINED + + +notdefined = IfcElectricMotorTypeEnum.NOTDEFINED + + +IfcElectricTimeControlTypeEnum = enum_namespace() + + +timeclock = IfcElectricTimeControlTypeEnum.TIMECLOCK + + +timedelay = IfcElectricTimeControlTypeEnum.TIMEDELAY + + +relay = IfcElectricTimeControlTypeEnum.RELAY + + +userdefined = IfcElectricTimeControlTypeEnum.USERDEFINED + + +notdefined = IfcElectricTimeControlTypeEnum.NOTDEFINED + + +IfcElementAssemblyTypeEnum = enum_namespace() + + +accessory_assembly = IfcElementAssemblyTypeEnum.ACCESSORY_ASSEMBLY + + +arch = IfcElementAssemblyTypeEnum.ARCH + + +beam_grid = IfcElementAssemblyTypeEnum.BEAM_GRID + + +braced_frame = IfcElementAssemblyTypeEnum.BRACED_FRAME + + +girder = IfcElementAssemblyTypeEnum.GIRDER + + +reinforcement_unit = IfcElementAssemblyTypeEnum.REINFORCEMENT_UNIT + + +rigid_frame = IfcElementAssemblyTypeEnum.RIGID_FRAME + + +slab_field = IfcElementAssemblyTypeEnum.SLAB_FIELD + + +truss = IfcElementAssemblyTypeEnum.TRUSS + + +userdefined = IfcElementAssemblyTypeEnum.USERDEFINED + + +notdefined = IfcElementAssemblyTypeEnum.NOTDEFINED + + +IfcElementCompositionEnum = enum_namespace() + + +complex = IfcElementCompositionEnum.COMPLEX + + +element = IfcElementCompositionEnum.ELEMENT + + +partial = IfcElementCompositionEnum.PARTIAL + + +IfcEngineTypeEnum = enum_namespace() + + +externalcombustion = IfcEngineTypeEnum.EXTERNALCOMBUSTION + + +internalcombustion = IfcEngineTypeEnum.INTERNALCOMBUSTION + + +userdefined = IfcEngineTypeEnum.USERDEFINED + + +notdefined = IfcEngineTypeEnum.NOTDEFINED + + +IfcEvaporativeCoolerTypeEnum = enum_namespace() + + +directevaporativerandommediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER + + +directevaporativerigidmediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER + + +directevaporativeslingerspackagedaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER + + +directevaporativepackagedrotaryaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER + + +directevaporativeairwasher = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEAIRWASHER + + +indirectevaporativepackageaircooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEPACKAGEAIRCOOLER + + +indirectevaporativewetcoil = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEWETCOIL + + +indirectevaporativecoolingtowerorcoilcooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER + + +indirectdirectcombination = IfcEvaporativeCoolerTypeEnum.INDIRECTDIRECTCOMBINATION + + +userdefined = IfcEvaporativeCoolerTypeEnum.USERDEFINED + + +notdefined = IfcEvaporativeCoolerTypeEnum.NOTDEFINED + + +IfcEvaporatorTypeEnum = enum_namespace() + + +directexpansion = IfcEvaporatorTypeEnum.DIRECTEXPANSION + + +directexpansionshellandtube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONSHELLANDTUBE + + +directexpansiontubeintube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONTUBEINTUBE + + +directexpansionbrazedplate = IfcEvaporatorTypeEnum.DIRECTEXPANSIONBRAZEDPLATE + + +floodedshellandtube = IfcEvaporatorTypeEnum.FLOODEDSHELLANDTUBE + + +shellandcoil = IfcEvaporatorTypeEnum.SHELLANDCOIL + + +userdefined = IfcEvaporatorTypeEnum.USERDEFINED + + +notdefined = IfcEvaporatorTypeEnum.NOTDEFINED + + +IfcEventTriggerTypeEnum = enum_namespace() + + +eventrule = IfcEventTriggerTypeEnum.EVENTRULE + + +eventmessage = IfcEventTriggerTypeEnum.EVENTMESSAGE + + +eventtime = IfcEventTriggerTypeEnum.EVENTTIME + + +eventcomplex = IfcEventTriggerTypeEnum.EVENTCOMPLEX + + +userdefined = IfcEventTriggerTypeEnum.USERDEFINED + + +notdefined = IfcEventTriggerTypeEnum.NOTDEFINED + + +IfcEventTypeEnum = enum_namespace() + + +startevent = IfcEventTypeEnum.STARTEVENT + + +endevent = IfcEventTypeEnum.ENDEVENT + + +intermediateevent = IfcEventTypeEnum.INTERMEDIATEEVENT + + +userdefined = IfcEventTypeEnum.USERDEFINED + + +notdefined = IfcEventTypeEnum.NOTDEFINED + + +IfcExternalSpatialElementTypeEnum = enum_namespace() + + +external = IfcExternalSpatialElementTypeEnum.EXTERNAL + + +external_earth = IfcExternalSpatialElementTypeEnum.EXTERNAL_EARTH + + +external_water = IfcExternalSpatialElementTypeEnum.EXTERNAL_WATER + + +external_fire = IfcExternalSpatialElementTypeEnum.EXTERNAL_FIRE + + +userdefined = IfcExternalSpatialElementTypeEnum.USERDEFINED + + +notdefined = IfcExternalSpatialElementTypeEnum.NOTDEFINED + + +IfcFanTypeEnum = enum_namespace() + + +centrifugalforwardcurved = IfcFanTypeEnum.CENTRIFUGALFORWARDCURVED + + +centrifugalradial = IfcFanTypeEnum.CENTRIFUGALRADIAL + + +centrifugalbackwardinclinedcurved = IfcFanTypeEnum.CENTRIFUGALBACKWARDINCLINEDCURVED + + +centrifugalairfoil = IfcFanTypeEnum.CENTRIFUGALAIRFOIL + + +tubeaxial = IfcFanTypeEnum.TUBEAXIAL + + +vaneaxial = IfcFanTypeEnum.VANEAXIAL + + +propelloraxial = IfcFanTypeEnum.PROPELLORAXIAL + + +userdefined = IfcFanTypeEnum.USERDEFINED + + +notdefined = IfcFanTypeEnum.NOTDEFINED + + +IfcFastenerTypeEnum = enum_namespace() + + +glue = IfcFastenerTypeEnum.GLUE + + +mortar = IfcFastenerTypeEnum.MORTAR + + +weld = IfcFastenerTypeEnum.WELD + + +userdefined = IfcFastenerTypeEnum.USERDEFINED + + +notdefined = IfcFastenerTypeEnum.NOTDEFINED + + +IfcFilterTypeEnum = enum_namespace() + + +airparticlefilter = IfcFilterTypeEnum.AIRPARTICLEFILTER + + +compressedairfilter = IfcFilterTypeEnum.COMPRESSEDAIRFILTER + + +odorfilter = IfcFilterTypeEnum.ODORFILTER + + +oilfilter = IfcFilterTypeEnum.OILFILTER + + +strainer = IfcFilterTypeEnum.STRAINER + + +waterfilter = IfcFilterTypeEnum.WATERFILTER + + +userdefined = IfcFilterTypeEnum.USERDEFINED + + +notdefined = IfcFilterTypeEnum.NOTDEFINED + + +IfcFireSuppressionTerminalTypeEnum = enum_namespace() + + +breechinginlet = IfcFireSuppressionTerminalTypeEnum.BREECHINGINLET + + +firehydrant = IfcFireSuppressionTerminalTypeEnum.FIREHYDRANT + + +hosereel = IfcFireSuppressionTerminalTypeEnum.HOSEREEL + + +sprinkler = IfcFireSuppressionTerminalTypeEnum.SPRINKLER + + +sprinklerdeflector = IfcFireSuppressionTerminalTypeEnum.SPRINKLERDEFLECTOR + + +userdefined = IfcFireSuppressionTerminalTypeEnum.USERDEFINED + + +notdefined = IfcFireSuppressionTerminalTypeEnum.NOTDEFINED + + +IfcFlowDirectionEnum = enum_namespace() + + +source = IfcFlowDirectionEnum.SOURCE + + +sink = IfcFlowDirectionEnum.SINK + + +sourceandsink = IfcFlowDirectionEnum.SOURCEANDSINK + + +notdefined = IfcFlowDirectionEnum.NOTDEFINED + + +IfcFlowInstrumentTypeEnum = enum_namespace() + + +pressuregauge = IfcFlowInstrumentTypeEnum.PRESSUREGAUGE + + +thermometer = IfcFlowInstrumentTypeEnum.THERMOMETER + + +ammeter = IfcFlowInstrumentTypeEnum.AMMETER + + +frequencymeter = IfcFlowInstrumentTypeEnum.FREQUENCYMETER + + +powerfactormeter = IfcFlowInstrumentTypeEnum.POWERFACTORMETER + + +phaseanglemeter = IfcFlowInstrumentTypeEnum.PHASEANGLEMETER + + +voltmeter_peak = IfcFlowInstrumentTypeEnum.VOLTMETER_PEAK + + +voltmeter_rms = IfcFlowInstrumentTypeEnum.VOLTMETER_RMS + + +userdefined = IfcFlowInstrumentTypeEnum.USERDEFINED + + +notdefined = IfcFlowInstrumentTypeEnum.NOTDEFINED + + +IfcFlowMeterTypeEnum = enum_namespace() + + +energymeter = IfcFlowMeterTypeEnum.ENERGYMETER + + +gasmeter = IfcFlowMeterTypeEnum.GASMETER + + +oilmeter = IfcFlowMeterTypeEnum.OILMETER + + +watermeter = IfcFlowMeterTypeEnum.WATERMETER + + +userdefined = IfcFlowMeterTypeEnum.USERDEFINED + + +notdefined = IfcFlowMeterTypeEnum.NOTDEFINED + + +IfcFootingTypeEnum = enum_namespace() + + +caisson_foundation = IfcFootingTypeEnum.CAISSON_FOUNDATION + + +footing_beam = IfcFootingTypeEnum.FOOTING_BEAM + + +pad_footing = IfcFootingTypeEnum.PAD_FOOTING + + +pile_cap = IfcFootingTypeEnum.PILE_CAP + + +strip_footing = IfcFootingTypeEnum.STRIP_FOOTING + + +userdefined = IfcFootingTypeEnum.USERDEFINED + + +notdefined = IfcFootingTypeEnum.NOTDEFINED + + +IfcFurnitureTypeEnum = enum_namespace() + + +chair = IfcFurnitureTypeEnum.CHAIR + + +table = IfcFurnitureTypeEnum.TABLE + + +desk = IfcFurnitureTypeEnum.DESK + + +bed = IfcFurnitureTypeEnum.BED + + +filecabinet = IfcFurnitureTypeEnum.FILECABINET + + +shelf = IfcFurnitureTypeEnum.SHELF + + +sofa = IfcFurnitureTypeEnum.SOFA + + +userdefined = IfcFurnitureTypeEnum.USERDEFINED + + +notdefined = IfcFurnitureTypeEnum.NOTDEFINED + + +IfcGeographicElementTypeEnum = enum_namespace() + + +terrain = IfcGeographicElementTypeEnum.TERRAIN + + +userdefined = IfcGeographicElementTypeEnum.USERDEFINED + + +notdefined = IfcGeographicElementTypeEnum.NOTDEFINED + + +IfcGeometricProjectionEnum = enum_namespace() + + +graph_view = IfcGeometricProjectionEnum.GRAPH_VIEW + + +sketch_view = IfcGeometricProjectionEnum.SKETCH_VIEW + + +model_view = IfcGeometricProjectionEnum.MODEL_VIEW + + +plan_view = IfcGeometricProjectionEnum.PLAN_VIEW + + +reflected_plan_view = IfcGeometricProjectionEnum.REFLECTED_PLAN_VIEW + + +section_view = IfcGeometricProjectionEnum.SECTION_VIEW + + +elevation_view = IfcGeometricProjectionEnum.ELEVATION_VIEW + + +userdefined = IfcGeometricProjectionEnum.USERDEFINED + + +notdefined = IfcGeometricProjectionEnum.NOTDEFINED + + +IfcGlobalOrLocalEnum = enum_namespace() + + +global_coords = IfcGlobalOrLocalEnum.GLOBAL_COORDS + + +local_coords = IfcGlobalOrLocalEnum.LOCAL_COORDS + + +IfcGridTypeEnum = enum_namespace() + + +rectangular = IfcGridTypeEnum.RECTANGULAR + + +radial = IfcGridTypeEnum.RADIAL + + +triangular = IfcGridTypeEnum.TRIANGULAR + + +irregular = IfcGridTypeEnum.IRREGULAR + + +userdefined = IfcGridTypeEnum.USERDEFINED + + +notdefined = IfcGridTypeEnum.NOTDEFINED + + +IfcHeatExchangerTypeEnum = enum_namespace() + + +plate = IfcHeatExchangerTypeEnum.PLATE + + +shellandtube = IfcHeatExchangerTypeEnum.SHELLANDTUBE + + +userdefined = IfcHeatExchangerTypeEnum.USERDEFINED + + +notdefined = IfcHeatExchangerTypeEnum.NOTDEFINED + + +IfcHumidifierTypeEnum = enum_namespace() + + +steaminjection = IfcHumidifierTypeEnum.STEAMINJECTION + + +adiabaticairwasher = IfcHumidifierTypeEnum.ADIABATICAIRWASHER + + +adiabaticpan = IfcHumidifierTypeEnum.ADIABATICPAN + + +adiabaticwettedelement = IfcHumidifierTypeEnum.ADIABATICWETTEDELEMENT + + +adiabaticatomizing = IfcHumidifierTypeEnum.ADIABATICATOMIZING + + +adiabaticultrasonic = IfcHumidifierTypeEnum.ADIABATICULTRASONIC + + +adiabaticrigidmedia = IfcHumidifierTypeEnum.ADIABATICRIGIDMEDIA + + +adiabaticcompressedairnozzle = IfcHumidifierTypeEnum.ADIABATICCOMPRESSEDAIRNOZZLE + + +assistedelectric = IfcHumidifierTypeEnum.ASSISTEDELECTRIC + + +assistednaturalgas = IfcHumidifierTypeEnum.ASSISTEDNATURALGAS + + +assistedpropane = IfcHumidifierTypeEnum.ASSISTEDPROPANE + + +assistedbutane = IfcHumidifierTypeEnum.ASSISTEDBUTANE + + +assistedsteam = IfcHumidifierTypeEnum.ASSISTEDSTEAM + + +userdefined = IfcHumidifierTypeEnum.USERDEFINED + + +notdefined = IfcHumidifierTypeEnum.NOTDEFINED + + +IfcInterceptorTypeEnum = enum_namespace() + + +cyclonic = IfcInterceptorTypeEnum.CYCLONIC + + +grease = IfcInterceptorTypeEnum.GREASE + + +oil = IfcInterceptorTypeEnum.OIL + + +petrol = IfcInterceptorTypeEnum.PETROL + + +userdefined = IfcInterceptorTypeEnum.USERDEFINED + + +notdefined = IfcInterceptorTypeEnum.NOTDEFINED + + +IfcInternalOrExternalEnum = enum_namespace() + + +internal = IfcInternalOrExternalEnum.INTERNAL + + +external = IfcInternalOrExternalEnum.EXTERNAL + + +external_earth = IfcInternalOrExternalEnum.EXTERNAL_EARTH + + +external_water = IfcInternalOrExternalEnum.EXTERNAL_WATER + + +external_fire = IfcInternalOrExternalEnum.EXTERNAL_FIRE + + +notdefined = IfcInternalOrExternalEnum.NOTDEFINED + + +IfcInventoryTypeEnum = enum_namespace() + + +assetinventory = IfcInventoryTypeEnum.ASSETINVENTORY + + +spaceinventory = IfcInventoryTypeEnum.SPACEINVENTORY + + +furnitureinventory = IfcInventoryTypeEnum.FURNITUREINVENTORY + + +userdefined = IfcInventoryTypeEnum.USERDEFINED + + +notdefined = IfcInventoryTypeEnum.NOTDEFINED + + +IfcJunctionBoxTypeEnum = enum_namespace() + + +data = IfcJunctionBoxTypeEnum.DATA + + +power = IfcJunctionBoxTypeEnum.POWER + + +userdefined = IfcJunctionBoxTypeEnum.USERDEFINED + + +notdefined = IfcJunctionBoxTypeEnum.NOTDEFINED + + +IfcKnotType = enum_namespace() + + +uniform_knots = IfcKnotType.UNIFORM_KNOTS + + +quasi_uniform_knots = IfcKnotType.QUASI_UNIFORM_KNOTS + + +piecewise_bezier_knots = IfcKnotType.PIECEWISE_BEZIER_KNOTS + + +unspecified = IfcKnotType.UNSPECIFIED + + +IfcLaborResourceTypeEnum = enum_namespace() + + +administration = IfcLaborResourceTypeEnum.ADMINISTRATION + + +carpentry = IfcLaborResourceTypeEnum.CARPENTRY + + +cleaning = IfcLaborResourceTypeEnum.CLEANING + + +concrete = IfcLaborResourceTypeEnum.CONCRETE + + +drywall = IfcLaborResourceTypeEnum.DRYWALL + + +electric = IfcLaborResourceTypeEnum.ELECTRIC + + +finishing = IfcLaborResourceTypeEnum.FINISHING + + +flooring = IfcLaborResourceTypeEnum.FLOORING + + +general = IfcLaborResourceTypeEnum.GENERAL + + +hvac = IfcLaborResourceTypeEnum.HVAC + + +landscaping = IfcLaborResourceTypeEnum.LANDSCAPING + + +masonry = IfcLaborResourceTypeEnum.MASONRY + + +painting = IfcLaborResourceTypeEnum.PAINTING + + +paving = IfcLaborResourceTypeEnum.PAVING + + +plumbing = IfcLaborResourceTypeEnum.PLUMBING + + +roofing = IfcLaborResourceTypeEnum.ROOFING + + +sitegrading = IfcLaborResourceTypeEnum.SITEGRADING + + +steelwork = IfcLaborResourceTypeEnum.STEELWORK + + +surveying = IfcLaborResourceTypeEnum.SURVEYING + + +userdefined = IfcLaborResourceTypeEnum.USERDEFINED + + +notdefined = IfcLaborResourceTypeEnum.NOTDEFINED + + +IfcLampTypeEnum = enum_namespace() + + +compactfluorescent = IfcLampTypeEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLampTypeEnum.FLUORESCENT + + +halogen = IfcLampTypeEnum.HALOGEN + + +highpressuremercury = IfcLampTypeEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLampTypeEnum.HIGHPRESSURESODIUM + + +led = IfcLampTypeEnum.LED + + +metalhalide = IfcLampTypeEnum.METALHALIDE + + +oled = IfcLampTypeEnum.OLED + + +tungstenfilament = IfcLampTypeEnum.TUNGSTENFILAMENT + + +userdefined = IfcLampTypeEnum.USERDEFINED + + +notdefined = IfcLampTypeEnum.NOTDEFINED + + +IfcLayerSetDirectionEnum = enum_namespace() + + +axis1 = IfcLayerSetDirectionEnum.AXIS1 + + +axis2 = IfcLayerSetDirectionEnum.AXIS2 + + +axis3 = IfcLayerSetDirectionEnum.AXIS3 + + +IfcLightDistributionCurveEnum = enum_namespace() + + +type_a = IfcLightDistributionCurveEnum.TYPE_A + + +type_b = IfcLightDistributionCurveEnum.TYPE_B + + +type_c = IfcLightDistributionCurveEnum.TYPE_C + + +notdefined = IfcLightDistributionCurveEnum.NOTDEFINED + + +IfcLightEmissionSourceEnum = enum_namespace() + + +compactfluorescent = IfcLightEmissionSourceEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLightEmissionSourceEnum.FLUORESCENT + + +highpressuremercury = IfcLightEmissionSourceEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLightEmissionSourceEnum.HIGHPRESSURESODIUM + + +lightemittingdiode = IfcLightEmissionSourceEnum.LIGHTEMITTINGDIODE + + +lowpressuresodium = IfcLightEmissionSourceEnum.LOWPRESSURESODIUM + + +lowvoltagehalogen = IfcLightEmissionSourceEnum.LOWVOLTAGEHALOGEN + + +mainvoltagehalogen = IfcLightEmissionSourceEnum.MAINVOLTAGEHALOGEN + + +metalhalide = IfcLightEmissionSourceEnum.METALHALIDE + + +tungstenfilament = IfcLightEmissionSourceEnum.TUNGSTENFILAMENT + + +notdefined = IfcLightEmissionSourceEnum.NOTDEFINED + + +IfcLightFixtureTypeEnum = enum_namespace() + + +pointsource = IfcLightFixtureTypeEnum.POINTSOURCE + + +directionsource = IfcLightFixtureTypeEnum.DIRECTIONSOURCE + + +securitylighting = IfcLightFixtureTypeEnum.SECURITYLIGHTING + + +userdefined = IfcLightFixtureTypeEnum.USERDEFINED + + +notdefined = IfcLightFixtureTypeEnum.NOTDEFINED + + +IfcLoadGroupTypeEnum = enum_namespace() + + +load_group = IfcLoadGroupTypeEnum.LOAD_GROUP + + +load_case = IfcLoadGroupTypeEnum.LOAD_CASE + + +load_combination = IfcLoadGroupTypeEnum.LOAD_COMBINATION + + +userdefined = IfcLoadGroupTypeEnum.USERDEFINED + + +notdefined = IfcLoadGroupTypeEnum.NOTDEFINED + + +IfcLogicalOperatorEnum = enum_namespace() + + +logicaland = IfcLogicalOperatorEnum.LOGICALAND + + +logicalor = IfcLogicalOperatorEnum.LOGICALOR + + +logicalxor = IfcLogicalOperatorEnum.LOGICALXOR + + +logicalnotand = IfcLogicalOperatorEnum.LOGICALNOTAND + + +logicalnotor = IfcLogicalOperatorEnum.LOGICALNOTOR + + +IfcMechanicalFastenerTypeEnum = enum_namespace() + + +anchorbolt = IfcMechanicalFastenerTypeEnum.ANCHORBOLT + + +bolt = IfcMechanicalFastenerTypeEnum.BOLT + + +dowel = IfcMechanicalFastenerTypeEnum.DOWEL + + +nail = IfcMechanicalFastenerTypeEnum.NAIL + + +nailplate = IfcMechanicalFastenerTypeEnum.NAILPLATE + + +rivet = IfcMechanicalFastenerTypeEnum.RIVET + + +screw = IfcMechanicalFastenerTypeEnum.SCREW + + +shearconnector = IfcMechanicalFastenerTypeEnum.SHEARCONNECTOR + + +staple = IfcMechanicalFastenerTypeEnum.STAPLE + + +studshearconnector = IfcMechanicalFastenerTypeEnum.STUDSHEARCONNECTOR + + +userdefined = IfcMechanicalFastenerTypeEnum.USERDEFINED + + +notdefined = IfcMechanicalFastenerTypeEnum.NOTDEFINED + + +IfcMedicalDeviceTypeEnum = enum_namespace() + + +airstation = IfcMedicalDeviceTypeEnum.AIRSTATION + + +feedairunit = IfcMedicalDeviceTypeEnum.FEEDAIRUNIT + + +oxygengenerator = IfcMedicalDeviceTypeEnum.OXYGENGENERATOR + + +oxygenplant = IfcMedicalDeviceTypeEnum.OXYGENPLANT + + +vacuumstation = IfcMedicalDeviceTypeEnum.VACUUMSTATION + + +userdefined = IfcMedicalDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMedicalDeviceTypeEnum.NOTDEFINED + + +IfcMemberTypeEnum = enum_namespace() + + +brace = IfcMemberTypeEnum.BRACE + + +chord = IfcMemberTypeEnum.CHORD + + +collar = IfcMemberTypeEnum.COLLAR + + +member = IfcMemberTypeEnum.MEMBER + + +mullion = IfcMemberTypeEnum.MULLION + + +plate = IfcMemberTypeEnum.PLATE + + +post = IfcMemberTypeEnum.POST + + +purlin = IfcMemberTypeEnum.PURLIN + + +rafter = IfcMemberTypeEnum.RAFTER + + +stringer = IfcMemberTypeEnum.STRINGER + + +strut = IfcMemberTypeEnum.STRUT + + +stud = IfcMemberTypeEnum.STUD + + +userdefined = IfcMemberTypeEnum.USERDEFINED + + +notdefined = IfcMemberTypeEnum.NOTDEFINED + + +IfcMotorConnectionTypeEnum = enum_namespace() + + +beltdrive = IfcMotorConnectionTypeEnum.BELTDRIVE + + +coupling = IfcMotorConnectionTypeEnum.COUPLING + + +directdrive = IfcMotorConnectionTypeEnum.DIRECTDRIVE + + +userdefined = IfcMotorConnectionTypeEnum.USERDEFINED + + +notdefined = IfcMotorConnectionTypeEnum.NOTDEFINED + + +IfcNullStyle = enum_namespace() + + +null = IfcNullStyle.NULL + + +IfcObjectTypeEnum = enum_namespace() + + +product = IfcObjectTypeEnum.PRODUCT + + +process = IfcObjectTypeEnum.PROCESS + + +control = IfcObjectTypeEnum.CONTROL + + +resource = IfcObjectTypeEnum.RESOURCE + + +actor = IfcObjectTypeEnum.ACTOR + + +group = IfcObjectTypeEnum.GROUP + + +project = IfcObjectTypeEnum.PROJECT + + +notdefined = IfcObjectTypeEnum.NOTDEFINED + + +IfcObjectiveEnum = enum_namespace() + + +codecompliance = IfcObjectiveEnum.CODECOMPLIANCE + + +codewaiver = IfcObjectiveEnum.CODEWAIVER + + +designintent = IfcObjectiveEnum.DESIGNINTENT + + +external = IfcObjectiveEnum.EXTERNAL + + +healthandsafety = IfcObjectiveEnum.HEALTHANDSAFETY + + +mergeconflict = IfcObjectiveEnum.MERGECONFLICT + + +modelview = IfcObjectiveEnum.MODELVIEW + + +parameter = IfcObjectiveEnum.PARAMETER + + +requirement = IfcObjectiveEnum.REQUIREMENT + + +specification = IfcObjectiveEnum.SPECIFICATION + + +triggercondition = IfcObjectiveEnum.TRIGGERCONDITION + + +userdefined = IfcObjectiveEnum.USERDEFINED + + +notdefined = IfcObjectiveEnum.NOTDEFINED + + +IfcOccupantTypeEnum = enum_namespace() + + +assignee = IfcOccupantTypeEnum.ASSIGNEE + + +assignor = IfcOccupantTypeEnum.ASSIGNOR + + +lessee = IfcOccupantTypeEnum.LESSEE + + +lessor = IfcOccupantTypeEnum.LESSOR + + +lettingagent = IfcOccupantTypeEnum.LETTINGAGENT + + +owner = IfcOccupantTypeEnum.OWNER + + +tenant = IfcOccupantTypeEnum.TENANT + + +userdefined = IfcOccupantTypeEnum.USERDEFINED + + +notdefined = IfcOccupantTypeEnum.NOTDEFINED + + +IfcOpeningElementTypeEnum = enum_namespace() + + +opening = IfcOpeningElementTypeEnum.OPENING + + +recess = IfcOpeningElementTypeEnum.RECESS + + +userdefined = IfcOpeningElementTypeEnum.USERDEFINED + + +notdefined = IfcOpeningElementTypeEnum.NOTDEFINED + + +IfcOutletTypeEnum = enum_namespace() + + +audiovisualoutlet = IfcOutletTypeEnum.AUDIOVISUALOUTLET + + +communicationsoutlet = IfcOutletTypeEnum.COMMUNICATIONSOUTLET + + +poweroutlet = IfcOutletTypeEnum.POWEROUTLET + + +dataoutlet = IfcOutletTypeEnum.DATAOUTLET + + +telephoneoutlet = IfcOutletTypeEnum.TELEPHONEOUTLET + + +userdefined = IfcOutletTypeEnum.USERDEFINED + + +notdefined = IfcOutletTypeEnum.NOTDEFINED + + +IfcPerformanceHistoryTypeEnum = enum_namespace() + + +userdefined = IfcPerformanceHistoryTypeEnum.USERDEFINED + + +notdefined = IfcPerformanceHistoryTypeEnum.NOTDEFINED + + +IfcPermeableCoveringOperationEnum = enum_namespace() + + +grill = IfcPermeableCoveringOperationEnum.GRILL + + +louver = IfcPermeableCoveringOperationEnum.LOUVER + + +screen = IfcPermeableCoveringOperationEnum.SCREEN + + +userdefined = IfcPermeableCoveringOperationEnum.USERDEFINED + + +notdefined = IfcPermeableCoveringOperationEnum.NOTDEFINED + + +IfcPermitTypeEnum = enum_namespace() + + +access = IfcPermitTypeEnum.ACCESS + + +building = IfcPermitTypeEnum.BUILDING + + +work = IfcPermitTypeEnum.WORK + + +userdefined = IfcPermitTypeEnum.USERDEFINED + + +notdefined = IfcPermitTypeEnum.NOTDEFINED + + +IfcPhysicalOrVirtualEnum = enum_namespace() + + +physical = IfcPhysicalOrVirtualEnum.PHYSICAL + + +virtual = IfcPhysicalOrVirtualEnum.VIRTUAL + + +notdefined = IfcPhysicalOrVirtualEnum.NOTDEFINED + + +IfcPileConstructionEnum = enum_namespace() + + +cast_in_place = IfcPileConstructionEnum.CAST_IN_PLACE + + +composite = IfcPileConstructionEnum.COMPOSITE + + +precast_concrete = IfcPileConstructionEnum.PRECAST_CONCRETE + + +prefab_steel = IfcPileConstructionEnum.PREFAB_STEEL + + +userdefined = IfcPileConstructionEnum.USERDEFINED + + +notdefined = IfcPileConstructionEnum.NOTDEFINED + + +IfcPileTypeEnum = enum_namespace() + + +bored = IfcPileTypeEnum.BORED + + +driven = IfcPileTypeEnum.DRIVEN + + +jetgrouting = IfcPileTypeEnum.JETGROUTING + + +cohesion = IfcPileTypeEnum.COHESION + + +friction = IfcPileTypeEnum.FRICTION + + +support = IfcPileTypeEnum.SUPPORT + + +userdefined = IfcPileTypeEnum.USERDEFINED + + +notdefined = IfcPileTypeEnum.NOTDEFINED + + +IfcPipeFittingTypeEnum = enum_namespace() + + +bend = IfcPipeFittingTypeEnum.BEND + + +connector = IfcPipeFittingTypeEnum.CONNECTOR + + +entry = IfcPipeFittingTypeEnum.ENTRY + + +exit = IfcPipeFittingTypeEnum.EXIT + + +junction = IfcPipeFittingTypeEnum.JUNCTION + + +obstruction = IfcPipeFittingTypeEnum.OBSTRUCTION + + +transition = IfcPipeFittingTypeEnum.TRANSITION + + +userdefined = IfcPipeFittingTypeEnum.USERDEFINED + + +notdefined = IfcPipeFittingTypeEnum.NOTDEFINED + + +IfcPipeSegmentTypeEnum = enum_namespace() + + +culvert = IfcPipeSegmentTypeEnum.CULVERT + + +flexiblesegment = IfcPipeSegmentTypeEnum.FLEXIBLESEGMENT + + +rigidsegment = IfcPipeSegmentTypeEnum.RIGIDSEGMENT + + +gutter = IfcPipeSegmentTypeEnum.GUTTER + + +spool = IfcPipeSegmentTypeEnum.SPOOL + + +userdefined = IfcPipeSegmentTypeEnum.USERDEFINED + + +notdefined = IfcPipeSegmentTypeEnum.NOTDEFINED + + +IfcPlateTypeEnum = enum_namespace() + + +curtain_panel = IfcPlateTypeEnum.CURTAIN_PANEL + + +sheet = IfcPlateTypeEnum.SHEET + + +userdefined = IfcPlateTypeEnum.USERDEFINED + + +notdefined = IfcPlateTypeEnum.NOTDEFINED + + +IfcPreferredSurfaceCurveRepresentation = enum_namespace() + + +curve3d = IfcPreferredSurfaceCurveRepresentation.CURVE3D + + +pcurve_s1 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S1 + + +pcurve_s2 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S2 + + +IfcProcedureTypeEnum = enum_namespace() + + +advice_caution = IfcProcedureTypeEnum.ADVICE_CAUTION + + +advice_note = IfcProcedureTypeEnum.ADVICE_NOTE + + +advice_warning = IfcProcedureTypeEnum.ADVICE_WARNING + + +calibration = IfcProcedureTypeEnum.CALIBRATION + + +diagnostic = IfcProcedureTypeEnum.DIAGNOSTIC + + +shutdown = IfcProcedureTypeEnum.SHUTDOWN + + +startup = IfcProcedureTypeEnum.STARTUP + + +userdefined = IfcProcedureTypeEnum.USERDEFINED + + +notdefined = IfcProcedureTypeEnum.NOTDEFINED + + +IfcProfileTypeEnum = enum_namespace() + + +curve = IfcProfileTypeEnum.CURVE + + +area = IfcProfileTypeEnum.AREA + + +IfcProjectOrderTypeEnum = enum_namespace() + + +changeorder = IfcProjectOrderTypeEnum.CHANGEORDER + + +maintenanceworkorder = IfcProjectOrderTypeEnum.MAINTENANCEWORKORDER + + +moveorder = IfcProjectOrderTypeEnum.MOVEORDER + + +purchaseorder = IfcProjectOrderTypeEnum.PURCHASEORDER + + +workorder = IfcProjectOrderTypeEnum.WORKORDER + + +userdefined = IfcProjectOrderTypeEnum.USERDEFINED + + +notdefined = IfcProjectOrderTypeEnum.NOTDEFINED + + +IfcProjectedOrTrueLengthEnum = enum_namespace() + + +projected_length = IfcProjectedOrTrueLengthEnum.PROJECTED_LENGTH + + +true_length = IfcProjectedOrTrueLengthEnum.TRUE_LENGTH + + +IfcProjectionElementTypeEnum = enum_namespace() + + +userdefined = IfcProjectionElementTypeEnum.USERDEFINED + + +notdefined = IfcProjectionElementTypeEnum.NOTDEFINED + + +IfcPropertySetTemplateTypeEnum = enum_namespace() + + +pset_typedrivenonly = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENONLY + + +pset_typedrivenoverride = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENOVERRIDE + + +pset_occurrencedriven = IfcPropertySetTemplateTypeEnum.PSET_OCCURRENCEDRIVEN + + +pset_performancedriven = IfcPropertySetTemplateTypeEnum.PSET_PERFORMANCEDRIVEN + + +qto_typedrivenonly = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENONLY + + +qto_typedrivenoverride = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENOVERRIDE + + +qto_occurrencedriven = IfcPropertySetTemplateTypeEnum.QTO_OCCURRENCEDRIVEN + + +notdefined = IfcPropertySetTemplateTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTrippingUnitTypeEnum = enum_namespace() + + +electronic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTRONIC + + +electromagnetic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTROMAGNETIC + + +residualcurrent = IfcProtectiveDeviceTrippingUnitTypeEnum.RESIDUALCURRENT + + +thermal = IfcProtectiveDeviceTrippingUnitTypeEnum.THERMAL + + +userdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTypeEnum = enum_namespace() + + +circuitbreaker = IfcProtectiveDeviceTypeEnum.CIRCUITBREAKER + + +earthleakagecircuitbreaker = IfcProtectiveDeviceTypeEnum.EARTHLEAKAGECIRCUITBREAKER + + +earthingswitch = IfcProtectiveDeviceTypeEnum.EARTHINGSWITCH + + +fusedisconnector = IfcProtectiveDeviceTypeEnum.FUSEDISCONNECTOR + + +residualcurrentcircuitbreaker = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTCIRCUITBREAKER + + +residualcurrentswitch = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTSWITCH + + +varistor = IfcProtectiveDeviceTypeEnum.VARISTOR + + +userdefined = IfcProtectiveDeviceTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTypeEnum.NOTDEFINED + + +IfcPumpTypeEnum = enum_namespace() + + +circulator = IfcPumpTypeEnum.CIRCULATOR + + +endsuction = IfcPumpTypeEnum.ENDSUCTION + + +splitcase = IfcPumpTypeEnum.SPLITCASE + + +submersiblepump = IfcPumpTypeEnum.SUBMERSIBLEPUMP + + +sumppump = IfcPumpTypeEnum.SUMPPUMP + + +verticalinline = IfcPumpTypeEnum.VERTICALINLINE + + +verticalturbine = IfcPumpTypeEnum.VERTICALTURBINE + + +userdefined = IfcPumpTypeEnum.USERDEFINED + + +notdefined = IfcPumpTypeEnum.NOTDEFINED + + +IfcRailingTypeEnum = enum_namespace() + + +handrail = IfcRailingTypeEnum.HANDRAIL + + +guardrail = IfcRailingTypeEnum.GUARDRAIL + + +balustrade = IfcRailingTypeEnum.BALUSTRADE + + +userdefined = IfcRailingTypeEnum.USERDEFINED + + +notdefined = IfcRailingTypeEnum.NOTDEFINED + + +IfcRampFlightTypeEnum = enum_namespace() + + +straight = IfcRampFlightTypeEnum.STRAIGHT + + +spiral = IfcRampFlightTypeEnum.SPIRAL + + +userdefined = IfcRampFlightTypeEnum.USERDEFINED + + +notdefined = IfcRampFlightTypeEnum.NOTDEFINED + + +IfcRampTypeEnum = enum_namespace() + + +straight_run_ramp = IfcRampTypeEnum.STRAIGHT_RUN_RAMP + + +two_straight_run_ramp = IfcRampTypeEnum.TWO_STRAIGHT_RUN_RAMP + + +quarter_turn_ramp = IfcRampTypeEnum.QUARTER_TURN_RAMP + + +two_quarter_turn_ramp = IfcRampTypeEnum.TWO_QUARTER_TURN_RAMP + + +half_turn_ramp = IfcRampTypeEnum.HALF_TURN_RAMP + + +spiral_ramp = IfcRampTypeEnum.SPIRAL_RAMP + + +userdefined = IfcRampTypeEnum.USERDEFINED + + +notdefined = IfcRampTypeEnum.NOTDEFINED + + +IfcRecurrenceTypeEnum = enum_namespace() + + +daily = IfcRecurrenceTypeEnum.DAILY + + +weekly = IfcRecurrenceTypeEnum.WEEKLY + + +monthly_by_day_of_month = IfcRecurrenceTypeEnum.MONTHLY_BY_DAY_OF_MONTH + + +monthly_by_position = IfcRecurrenceTypeEnum.MONTHLY_BY_POSITION + + +by_day_count = IfcRecurrenceTypeEnum.BY_DAY_COUNT + + +by_weekday_count = IfcRecurrenceTypeEnum.BY_WEEKDAY_COUNT + + +yearly_by_day_of_month = IfcRecurrenceTypeEnum.YEARLY_BY_DAY_OF_MONTH + + +yearly_by_position = IfcRecurrenceTypeEnum.YEARLY_BY_POSITION + + +IfcReflectanceMethodEnum = enum_namespace() + + +blinn = IfcReflectanceMethodEnum.BLINN + + +flat = IfcReflectanceMethodEnum.FLAT + + +glass = IfcReflectanceMethodEnum.GLASS + + +matt = IfcReflectanceMethodEnum.MATT + + +metal = IfcReflectanceMethodEnum.METAL + + +mirror = IfcReflectanceMethodEnum.MIRROR + + +phong = IfcReflectanceMethodEnum.PHONG + + +plastic = IfcReflectanceMethodEnum.PLASTIC + + +strauss = IfcReflectanceMethodEnum.STRAUSS + + +notdefined = IfcReflectanceMethodEnum.NOTDEFINED + + +IfcReinforcingBarRoleEnum = enum_namespace() + + +main = IfcReinforcingBarRoleEnum.MAIN + + +shear = IfcReinforcingBarRoleEnum.SHEAR + + +ligature = IfcReinforcingBarRoleEnum.LIGATURE + + +stud = IfcReinforcingBarRoleEnum.STUD + + +punching = IfcReinforcingBarRoleEnum.PUNCHING + + +edge = IfcReinforcingBarRoleEnum.EDGE + + +ring = IfcReinforcingBarRoleEnum.RING + + +anchoring = IfcReinforcingBarRoleEnum.ANCHORING + + +userdefined = IfcReinforcingBarRoleEnum.USERDEFINED + + +notdefined = IfcReinforcingBarRoleEnum.NOTDEFINED + + +IfcReinforcingBarSurfaceEnum = enum_namespace() + + +plain = IfcReinforcingBarSurfaceEnum.PLAIN + + +textured = IfcReinforcingBarSurfaceEnum.TEXTURED + + +IfcReinforcingBarTypeEnum = enum_namespace() + + +anchoring = IfcReinforcingBarTypeEnum.ANCHORING + + +edge = IfcReinforcingBarTypeEnum.EDGE + + +ligature = IfcReinforcingBarTypeEnum.LIGATURE + + +main = IfcReinforcingBarTypeEnum.MAIN + + +punching = IfcReinforcingBarTypeEnum.PUNCHING + + +ring = IfcReinforcingBarTypeEnum.RING + + +shear = IfcReinforcingBarTypeEnum.SHEAR + + +stud = IfcReinforcingBarTypeEnum.STUD + + +userdefined = IfcReinforcingBarTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingBarTypeEnum.NOTDEFINED + + +IfcReinforcingMeshTypeEnum = enum_namespace() + + +userdefined = IfcReinforcingMeshTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingMeshTypeEnum.NOTDEFINED + + +IfcRoleEnum = enum_namespace() + + +supplier = IfcRoleEnum.SUPPLIER + + +manufacturer = IfcRoleEnum.MANUFACTURER + + +contractor = IfcRoleEnum.CONTRACTOR + + +subcontractor = IfcRoleEnum.SUBCONTRACTOR + + +architect = IfcRoleEnum.ARCHITECT + + +structuralengineer = IfcRoleEnum.STRUCTURALENGINEER + + +costengineer = IfcRoleEnum.COSTENGINEER + + +client = IfcRoleEnum.CLIENT + + +buildingowner = IfcRoleEnum.BUILDINGOWNER + + +buildingoperator = IfcRoleEnum.BUILDINGOPERATOR + + +mechanicalengineer = IfcRoleEnum.MECHANICALENGINEER + + +electricalengineer = IfcRoleEnum.ELECTRICALENGINEER + + +projectmanager = IfcRoleEnum.PROJECTMANAGER + + +facilitiesmanager = IfcRoleEnum.FACILITIESMANAGER + + +civilengineer = IfcRoleEnum.CIVILENGINEER + + +commissioningengineer = IfcRoleEnum.COMMISSIONINGENGINEER + + +engineer = IfcRoleEnum.ENGINEER + + +owner = IfcRoleEnum.OWNER + + +consultant = IfcRoleEnum.CONSULTANT + + +constructionmanager = IfcRoleEnum.CONSTRUCTIONMANAGER + + +fieldconstructionmanager = IfcRoleEnum.FIELDCONSTRUCTIONMANAGER + + +reseller = IfcRoleEnum.RESELLER + + +userdefined = IfcRoleEnum.USERDEFINED + + +IfcRoofTypeEnum = enum_namespace() + + +flat_roof = IfcRoofTypeEnum.FLAT_ROOF + + +shed_roof = IfcRoofTypeEnum.SHED_ROOF + + +gable_roof = IfcRoofTypeEnum.GABLE_ROOF + + +hip_roof = IfcRoofTypeEnum.HIP_ROOF + + +hipped_gable_roof = IfcRoofTypeEnum.HIPPED_GABLE_ROOF + + +gambrel_roof = IfcRoofTypeEnum.GAMBREL_ROOF + + +mansard_roof = IfcRoofTypeEnum.MANSARD_ROOF + + +barrel_roof = IfcRoofTypeEnum.BARREL_ROOF + + +rainbow_roof = IfcRoofTypeEnum.RAINBOW_ROOF + + +butterfly_roof = IfcRoofTypeEnum.BUTTERFLY_ROOF + + +pavilion_roof = IfcRoofTypeEnum.PAVILION_ROOF + + +dome_roof = IfcRoofTypeEnum.DOME_ROOF + + +freeform = IfcRoofTypeEnum.FREEFORM + + +userdefined = IfcRoofTypeEnum.USERDEFINED + + +notdefined = IfcRoofTypeEnum.NOTDEFINED + + +IfcSIPrefix = enum_namespace() + + +exa = IfcSIPrefix.EXA + + +peta = IfcSIPrefix.PETA + + +tera = IfcSIPrefix.TERA + + +giga = IfcSIPrefix.GIGA + + +mega = IfcSIPrefix.MEGA + + +kilo = IfcSIPrefix.KILO + + +hecto = IfcSIPrefix.HECTO + + +deca = IfcSIPrefix.DECA + + +deci = IfcSIPrefix.DECI + + +centi = IfcSIPrefix.CENTI + + +milli = IfcSIPrefix.MILLI + + +micro = IfcSIPrefix.MICRO + + +nano = IfcSIPrefix.NANO + + +pico = IfcSIPrefix.PICO + + +femto = IfcSIPrefix.FEMTO + + +atto = IfcSIPrefix.ATTO + + +IfcSIUnitName = enum_namespace() + + +ampere = IfcSIUnitName.AMPERE + + +becquerel = IfcSIUnitName.BECQUEREL + + +candela = IfcSIUnitName.CANDELA + + +coulomb = IfcSIUnitName.COULOMB + + +cubic_metre = IfcSIUnitName.CUBIC_METRE + + +degree_celsius = IfcSIUnitName.DEGREE_CELSIUS + + +farad = IfcSIUnitName.FARAD + + +gram = IfcSIUnitName.GRAM + + +gray = IfcSIUnitName.GRAY + + +henry = IfcSIUnitName.HENRY + + +hertz = IfcSIUnitName.HERTZ + + +joule = IfcSIUnitName.JOULE + + +kelvin = IfcSIUnitName.KELVIN + + +lumen = IfcSIUnitName.LUMEN + + +lux = IfcSIUnitName.LUX + + +metre = IfcSIUnitName.METRE + + +mole = IfcSIUnitName.MOLE + + +newton = IfcSIUnitName.NEWTON + + +ohm = IfcSIUnitName.OHM + + +pascal = IfcSIUnitName.PASCAL + + +radian = IfcSIUnitName.RADIAN + + +second = IfcSIUnitName.SECOND + + +siemens = IfcSIUnitName.SIEMENS + + +sievert = IfcSIUnitName.SIEVERT + + +square_metre = IfcSIUnitName.SQUARE_METRE + + +steradian = IfcSIUnitName.STERADIAN + + +tesla = IfcSIUnitName.TESLA + + +volt = IfcSIUnitName.VOLT + + +watt = IfcSIUnitName.WATT + + +weber = IfcSIUnitName.WEBER + + +IfcSanitaryTerminalTypeEnum = enum_namespace() + + +bath = IfcSanitaryTerminalTypeEnum.BATH + + +bidet = IfcSanitaryTerminalTypeEnum.BIDET + + +cistern = IfcSanitaryTerminalTypeEnum.CISTERN + + +shower = IfcSanitaryTerminalTypeEnum.SHOWER + + +sink = IfcSanitaryTerminalTypeEnum.SINK + + +sanitaryfountain = IfcSanitaryTerminalTypeEnum.SANITARYFOUNTAIN + + +toiletpan = IfcSanitaryTerminalTypeEnum.TOILETPAN + + +urinal = IfcSanitaryTerminalTypeEnum.URINAL + + +washhandbasin = IfcSanitaryTerminalTypeEnum.WASHHANDBASIN + + +wcseat = IfcSanitaryTerminalTypeEnum.WCSEAT + + +userdefined = IfcSanitaryTerminalTypeEnum.USERDEFINED + + +notdefined = IfcSanitaryTerminalTypeEnum.NOTDEFINED + + +IfcSectionTypeEnum = enum_namespace() + + +uniform = IfcSectionTypeEnum.UNIFORM + + +tapered = IfcSectionTypeEnum.TAPERED + + +IfcSensorTypeEnum = enum_namespace() + + +cosensor = IfcSensorTypeEnum.COSENSOR + + +co2sensor = IfcSensorTypeEnum.CO2SENSOR + + +conductancesensor = IfcSensorTypeEnum.CONDUCTANCESENSOR + + +contactsensor = IfcSensorTypeEnum.CONTACTSENSOR + + +firesensor = IfcSensorTypeEnum.FIRESENSOR + + +flowsensor = IfcSensorTypeEnum.FLOWSENSOR + + +frostsensor = IfcSensorTypeEnum.FROSTSENSOR + + +gassensor = IfcSensorTypeEnum.GASSENSOR + + +heatsensor = IfcSensorTypeEnum.HEATSENSOR + + +humiditysensor = IfcSensorTypeEnum.HUMIDITYSENSOR + + +identifiersensor = IfcSensorTypeEnum.IDENTIFIERSENSOR + + +ionconcentrationsensor = IfcSensorTypeEnum.IONCONCENTRATIONSENSOR + + +levelsensor = IfcSensorTypeEnum.LEVELSENSOR + + +lightsensor = IfcSensorTypeEnum.LIGHTSENSOR + + +moisturesensor = IfcSensorTypeEnum.MOISTURESENSOR + + +movementsensor = IfcSensorTypeEnum.MOVEMENTSENSOR + + +phsensor = IfcSensorTypeEnum.PHSENSOR + + +pressuresensor = IfcSensorTypeEnum.PRESSURESENSOR + + +radiationsensor = IfcSensorTypeEnum.RADIATIONSENSOR + + +radioactivitysensor = IfcSensorTypeEnum.RADIOACTIVITYSENSOR + + +smokesensor = IfcSensorTypeEnum.SMOKESENSOR + + +soundsensor = IfcSensorTypeEnum.SOUNDSENSOR + + +temperaturesensor = IfcSensorTypeEnum.TEMPERATURESENSOR + + +windsensor = IfcSensorTypeEnum.WINDSENSOR + + +userdefined = IfcSensorTypeEnum.USERDEFINED + + +notdefined = IfcSensorTypeEnum.NOTDEFINED + + +IfcSequenceEnum = enum_namespace() + + +start_start = IfcSequenceEnum.START_START + + +start_finish = IfcSequenceEnum.START_FINISH + + +finish_start = IfcSequenceEnum.FINISH_START + + +finish_finish = IfcSequenceEnum.FINISH_FINISH + + +userdefined = IfcSequenceEnum.USERDEFINED + + +notdefined = IfcSequenceEnum.NOTDEFINED + + +IfcShadingDeviceTypeEnum = enum_namespace() + + +jalousie = IfcShadingDeviceTypeEnum.JALOUSIE + + +shutter = IfcShadingDeviceTypeEnum.SHUTTER + + +awning = IfcShadingDeviceTypeEnum.AWNING + + +userdefined = IfcShadingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcShadingDeviceTypeEnum.NOTDEFINED + + +IfcSimplePropertyTemplateTypeEnum = enum_namespace() + + +p_singlevalue = IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE + + +p_enumeratedvalue = IfcSimplePropertyTemplateTypeEnum.P_ENUMERATEDVALUE + + +p_boundedvalue = IfcSimplePropertyTemplateTypeEnum.P_BOUNDEDVALUE + + +p_listvalue = IfcSimplePropertyTemplateTypeEnum.P_LISTVALUE + + +p_tablevalue = IfcSimplePropertyTemplateTypeEnum.P_TABLEVALUE + + +p_referencevalue = IfcSimplePropertyTemplateTypeEnum.P_REFERENCEVALUE + + +q_length = IfcSimplePropertyTemplateTypeEnum.Q_LENGTH + + +q_area = IfcSimplePropertyTemplateTypeEnum.Q_AREA + + +q_volume = IfcSimplePropertyTemplateTypeEnum.Q_VOLUME + + +q_count = IfcSimplePropertyTemplateTypeEnum.Q_COUNT + + +q_weight = IfcSimplePropertyTemplateTypeEnum.Q_WEIGHT + + +q_time = IfcSimplePropertyTemplateTypeEnum.Q_TIME + + +IfcSlabTypeEnum = enum_namespace() + + +floor = IfcSlabTypeEnum.FLOOR + + +roof = IfcSlabTypeEnum.ROOF + + +landing = IfcSlabTypeEnum.LANDING + + +baseslab = IfcSlabTypeEnum.BASESLAB + + +userdefined = IfcSlabTypeEnum.USERDEFINED + + +notdefined = IfcSlabTypeEnum.NOTDEFINED + + +IfcSolarDeviceTypeEnum = enum_namespace() + + +solarcollector = IfcSolarDeviceTypeEnum.SOLARCOLLECTOR + + +solarpanel = IfcSolarDeviceTypeEnum.SOLARPANEL + + +userdefined = IfcSolarDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSolarDeviceTypeEnum.NOTDEFINED + + +IfcSpaceHeaterTypeEnum = enum_namespace() + + +convector = IfcSpaceHeaterTypeEnum.CONVECTOR + + +radiator = IfcSpaceHeaterTypeEnum.RADIATOR + + +userdefined = IfcSpaceHeaterTypeEnum.USERDEFINED + + +notdefined = IfcSpaceHeaterTypeEnum.NOTDEFINED + + +IfcSpaceTypeEnum = enum_namespace() + + +space = IfcSpaceTypeEnum.SPACE + + +parking = IfcSpaceTypeEnum.PARKING + + +gfa = IfcSpaceTypeEnum.GFA + + +internal = IfcSpaceTypeEnum.INTERNAL + + +external = IfcSpaceTypeEnum.EXTERNAL + + +userdefined = IfcSpaceTypeEnum.USERDEFINED + + +notdefined = IfcSpaceTypeEnum.NOTDEFINED + + +IfcSpatialZoneTypeEnum = enum_namespace() + + +construction = IfcSpatialZoneTypeEnum.CONSTRUCTION + + +firesafety = IfcSpatialZoneTypeEnum.FIRESAFETY + + +lighting = IfcSpatialZoneTypeEnum.LIGHTING + + +occupancy = IfcSpatialZoneTypeEnum.OCCUPANCY + + +security = IfcSpatialZoneTypeEnum.SECURITY + + +thermal = IfcSpatialZoneTypeEnum.THERMAL + + +transport = IfcSpatialZoneTypeEnum.TRANSPORT + + +ventilation = IfcSpatialZoneTypeEnum.VENTILATION + + +userdefined = IfcSpatialZoneTypeEnum.USERDEFINED + + +notdefined = IfcSpatialZoneTypeEnum.NOTDEFINED + + +IfcStackTerminalTypeEnum = enum_namespace() + + +birdcage = IfcStackTerminalTypeEnum.BIRDCAGE + + +cowl = IfcStackTerminalTypeEnum.COWL + + +rainwaterhopper = IfcStackTerminalTypeEnum.RAINWATERHOPPER + + +userdefined = IfcStackTerminalTypeEnum.USERDEFINED + + +notdefined = IfcStackTerminalTypeEnum.NOTDEFINED + + +IfcStairFlightTypeEnum = enum_namespace() + + +straight = IfcStairFlightTypeEnum.STRAIGHT + + +winder = IfcStairFlightTypeEnum.WINDER + + +spiral = IfcStairFlightTypeEnum.SPIRAL + + +curved = IfcStairFlightTypeEnum.CURVED + + +freeform = IfcStairFlightTypeEnum.FREEFORM + + +userdefined = IfcStairFlightTypeEnum.USERDEFINED + + +notdefined = IfcStairFlightTypeEnum.NOTDEFINED + + +IfcStairTypeEnum = enum_namespace() + + +straight_run_stair = IfcStairTypeEnum.STRAIGHT_RUN_STAIR + + +two_straight_run_stair = IfcStairTypeEnum.TWO_STRAIGHT_RUN_STAIR + + +quarter_winding_stair = IfcStairTypeEnum.QUARTER_WINDING_STAIR + + +quarter_turn_stair = IfcStairTypeEnum.QUARTER_TURN_STAIR + + +half_winding_stair = IfcStairTypeEnum.HALF_WINDING_STAIR + + +half_turn_stair = IfcStairTypeEnum.HALF_TURN_STAIR + + +two_quarter_winding_stair = IfcStairTypeEnum.TWO_QUARTER_WINDING_STAIR + + +two_quarter_turn_stair = IfcStairTypeEnum.TWO_QUARTER_TURN_STAIR + + +three_quarter_winding_stair = IfcStairTypeEnum.THREE_QUARTER_WINDING_STAIR + + +three_quarter_turn_stair = IfcStairTypeEnum.THREE_QUARTER_TURN_STAIR + + +spiral_stair = IfcStairTypeEnum.SPIRAL_STAIR + + +double_return_stair = IfcStairTypeEnum.DOUBLE_RETURN_STAIR + + +curved_run_stair = IfcStairTypeEnum.CURVED_RUN_STAIR + + +two_curved_run_stair = IfcStairTypeEnum.TWO_CURVED_RUN_STAIR + + +userdefined = IfcStairTypeEnum.USERDEFINED + + +notdefined = IfcStairTypeEnum.NOTDEFINED + + +IfcStateEnum = enum_namespace() + + +readwrite = IfcStateEnum.READWRITE + + +readonly = IfcStateEnum.READONLY + + +locked = IfcStateEnum.LOCKED + + +readwritelocked = IfcStateEnum.READWRITELOCKED + + +readonlylocked = IfcStateEnum.READONLYLOCKED + + +IfcStructuralCurveActivityTypeEnum = enum_namespace() + + +const = IfcStructuralCurveActivityTypeEnum.CONST + + +linear = IfcStructuralCurveActivityTypeEnum.LINEAR + + +polygonal = IfcStructuralCurveActivityTypeEnum.POLYGONAL + + +equidistant = IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + +sinus = IfcStructuralCurveActivityTypeEnum.SINUS + + +parabola = IfcStructuralCurveActivityTypeEnum.PARABOLA + + +discrete = IfcStructuralCurveActivityTypeEnum.DISCRETE + + +userdefined = IfcStructuralCurveActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveActivityTypeEnum.NOTDEFINED + + +IfcStructuralCurveMemberTypeEnum = enum_namespace() + + +rigid_joined_member = IfcStructuralCurveMemberTypeEnum.RIGID_JOINED_MEMBER + + +pin_joined_member = IfcStructuralCurveMemberTypeEnum.PIN_JOINED_MEMBER + + +cable = IfcStructuralCurveMemberTypeEnum.CABLE + + +tension_member = IfcStructuralCurveMemberTypeEnum.TENSION_MEMBER + + +compression_member = IfcStructuralCurveMemberTypeEnum.COMPRESSION_MEMBER + + +userdefined = IfcStructuralCurveMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveMemberTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceActivityTypeEnum = enum_namespace() + + +const = IfcStructuralSurfaceActivityTypeEnum.CONST + + +bilinear = IfcStructuralSurfaceActivityTypeEnum.BILINEAR + + +discrete = IfcStructuralSurfaceActivityTypeEnum.DISCRETE + + +isocontour = IfcStructuralSurfaceActivityTypeEnum.ISOCONTOUR + + +userdefined = IfcStructuralSurfaceActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceActivityTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceMemberTypeEnum = enum_namespace() + + +bending_element = IfcStructuralSurfaceMemberTypeEnum.BENDING_ELEMENT + + +membrane_element = IfcStructuralSurfaceMemberTypeEnum.MEMBRANE_ELEMENT + + +shell = IfcStructuralSurfaceMemberTypeEnum.SHELL + + +userdefined = IfcStructuralSurfaceMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceMemberTypeEnum.NOTDEFINED + + +IfcSubContractResourceTypeEnum = enum_namespace() + + +purchase = IfcSubContractResourceTypeEnum.PURCHASE + + +work = IfcSubContractResourceTypeEnum.WORK + + +userdefined = IfcSubContractResourceTypeEnum.USERDEFINED + + +notdefined = IfcSubContractResourceTypeEnum.NOTDEFINED + + +IfcSurfaceFeatureTypeEnum = enum_namespace() + + +mark = IfcSurfaceFeatureTypeEnum.MARK + + +tag = IfcSurfaceFeatureTypeEnum.TAG + + +treatment = IfcSurfaceFeatureTypeEnum.TREATMENT + + +userdefined = IfcSurfaceFeatureTypeEnum.USERDEFINED + + +notdefined = IfcSurfaceFeatureTypeEnum.NOTDEFINED + + +IfcSurfaceSide = enum_namespace() + + +positive = IfcSurfaceSide.POSITIVE + + +negative = IfcSurfaceSide.NEGATIVE + + +both = IfcSurfaceSide.BOTH + + +IfcSwitchingDeviceTypeEnum = enum_namespace() + + +contactor = IfcSwitchingDeviceTypeEnum.CONTACTOR + + +dimmerswitch = IfcSwitchingDeviceTypeEnum.DIMMERSWITCH + + +emergencystop = IfcSwitchingDeviceTypeEnum.EMERGENCYSTOP + + +keypad = IfcSwitchingDeviceTypeEnum.KEYPAD + + +momentaryswitch = IfcSwitchingDeviceTypeEnum.MOMENTARYSWITCH + + +selectorswitch = IfcSwitchingDeviceTypeEnum.SELECTORSWITCH + + +starter = IfcSwitchingDeviceTypeEnum.STARTER + + +switchdisconnector = IfcSwitchingDeviceTypeEnum.SWITCHDISCONNECTOR + + +toggleswitch = IfcSwitchingDeviceTypeEnum.TOGGLESWITCH + + +userdefined = IfcSwitchingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSwitchingDeviceTypeEnum.NOTDEFINED + + +IfcSystemFurnitureElementTypeEnum = enum_namespace() + + +panel = IfcSystemFurnitureElementTypeEnum.PANEL + + +worksurface = IfcSystemFurnitureElementTypeEnum.WORKSURFACE + + +userdefined = IfcSystemFurnitureElementTypeEnum.USERDEFINED + + +notdefined = IfcSystemFurnitureElementTypeEnum.NOTDEFINED + + +IfcTankTypeEnum = enum_namespace() + + +basin = IfcTankTypeEnum.BASIN + + +breakpressure = IfcTankTypeEnum.BREAKPRESSURE + + +expansion = IfcTankTypeEnum.EXPANSION + + +feedandexpansion = IfcTankTypeEnum.FEEDANDEXPANSION + + +pressurevessel = IfcTankTypeEnum.PRESSUREVESSEL + + +storage = IfcTankTypeEnum.STORAGE + + +vessel = IfcTankTypeEnum.VESSEL + + +userdefined = IfcTankTypeEnum.USERDEFINED + + +notdefined = IfcTankTypeEnum.NOTDEFINED + + +IfcTaskDurationEnum = enum_namespace() + + +elapsedtime = IfcTaskDurationEnum.ELAPSEDTIME + + +worktime = IfcTaskDurationEnum.WORKTIME + + +notdefined = IfcTaskDurationEnum.NOTDEFINED + + +IfcTaskTypeEnum = enum_namespace() + + +attendance = IfcTaskTypeEnum.ATTENDANCE + + +construction = IfcTaskTypeEnum.CONSTRUCTION + + +demolition = IfcTaskTypeEnum.DEMOLITION + + +dismantle = IfcTaskTypeEnum.DISMANTLE + + +disposal = IfcTaskTypeEnum.DISPOSAL + + +installation = IfcTaskTypeEnum.INSTALLATION + + +logistic = IfcTaskTypeEnum.LOGISTIC + + +maintenance = IfcTaskTypeEnum.MAINTENANCE + + +move = IfcTaskTypeEnum.MOVE + + +operation = IfcTaskTypeEnum.OPERATION + + +removal = IfcTaskTypeEnum.REMOVAL + + +renovation = IfcTaskTypeEnum.RENOVATION + + +userdefined = IfcTaskTypeEnum.USERDEFINED + + +notdefined = IfcTaskTypeEnum.NOTDEFINED + + +IfcTendonAnchorTypeEnum = enum_namespace() + + +coupler = IfcTendonAnchorTypeEnum.COUPLER + + +fixed_end = IfcTendonAnchorTypeEnum.FIXED_END + + +tensioning_end = IfcTendonAnchorTypeEnum.TENSIONING_END + + +userdefined = IfcTendonAnchorTypeEnum.USERDEFINED + + +notdefined = IfcTendonAnchorTypeEnum.NOTDEFINED + + +IfcTendonTypeEnum = enum_namespace() + + +bar = IfcTendonTypeEnum.BAR + + +coated = IfcTendonTypeEnum.COATED + + +strand = IfcTendonTypeEnum.STRAND + + +wire = IfcTendonTypeEnum.WIRE + + +userdefined = IfcTendonTypeEnum.USERDEFINED + + +notdefined = IfcTendonTypeEnum.NOTDEFINED + + +IfcTextPath = enum_namespace() + + +left = IfcTextPath.LEFT + + +right = IfcTextPath.RIGHT + + +up = IfcTextPath.UP + + +down = IfcTextPath.DOWN + + +IfcTimeSeriesDataTypeEnum = enum_namespace() + + +continuous = IfcTimeSeriesDataTypeEnum.CONTINUOUS + + +discrete = IfcTimeSeriesDataTypeEnum.DISCRETE + + +discretebinary = IfcTimeSeriesDataTypeEnum.DISCRETEBINARY + + +piecewisebinary = IfcTimeSeriesDataTypeEnum.PIECEWISEBINARY + + +piecewiseconstant = IfcTimeSeriesDataTypeEnum.PIECEWISECONSTANT + + +piecewisecontinuous = IfcTimeSeriesDataTypeEnum.PIECEWISECONTINUOUS + + +notdefined = IfcTimeSeriesDataTypeEnum.NOTDEFINED + + +IfcTransformerTypeEnum = enum_namespace() + + +current = IfcTransformerTypeEnum.CURRENT + + +frequency = IfcTransformerTypeEnum.FREQUENCY + + +inverter = IfcTransformerTypeEnum.INVERTER + + +rectifier = IfcTransformerTypeEnum.RECTIFIER + + +voltage = IfcTransformerTypeEnum.VOLTAGE + + +userdefined = IfcTransformerTypeEnum.USERDEFINED + + +notdefined = IfcTransformerTypeEnum.NOTDEFINED + + +IfcTransitionCode = enum_namespace() + + +discontinuous = IfcTransitionCode.DISCONTINUOUS + + +continuous = IfcTransitionCode.CONTINUOUS + + +contsamegradient = IfcTransitionCode.CONTSAMEGRADIENT + + +contsamegradientsamecurvature = IfcTransitionCode.CONTSAMEGRADIENTSAMECURVATURE + + +IfcTransportElementTypeEnum = enum_namespace() + + +elevator = IfcTransportElementTypeEnum.ELEVATOR + + +escalator = IfcTransportElementTypeEnum.ESCALATOR + + +movingwalkway = IfcTransportElementTypeEnum.MOVINGWALKWAY + + +craneway = IfcTransportElementTypeEnum.CRANEWAY + + +liftinggear = IfcTransportElementTypeEnum.LIFTINGGEAR + + +userdefined = IfcTransportElementTypeEnum.USERDEFINED + + +notdefined = IfcTransportElementTypeEnum.NOTDEFINED + + +IfcTrimmingPreference = enum_namespace() + + +cartesian = IfcTrimmingPreference.CARTESIAN + + +parameter = IfcTrimmingPreference.PARAMETER + + +unspecified = IfcTrimmingPreference.UNSPECIFIED + + +IfcTubeBundleTypeEnum = enum_namespace() + + +finned = IfcTubeBundleTypeEnum.FINNED + + +userdefined = IfcTubeBundleTypeEnum.USERDEFINED + + +notdefined = IfcTubeBundleTypeEnum.NOTDEFINED + + +IfcUnitEnum = enum_namespace() + + +absorbeddoseunit = IfcUnitEnum.ABSORBEDDOSEUNIT + + +amountofsubstanceunit = IfcUnitEnum.AMOUNTOFSUBSTANCEUNIT + + +areaunit = IfcUnitEnum.AREAUNIT + + +doseequivalentunit = IfcUnitEnum.DOSEEQUIVALENTUNIT + + +electriccapacitanceunit = IfcUnitEnum.ELECTRICCAPACITANCEUNIT + + +electricchargeunit = IfcUnitEnum.ELECTRICCHARGEUNIT + + +electricconductanceunit = IfcUnitEnum.ELECTRICCONDUCTANCEUNIT + + +electriccurrentunit = IfcUnitEnum.ELECTRICCURRENTUNIT + + +electricresistanceunit = IfcUnitEnum.ELECTRICRESISTANCEUNIT + + +electricvoltageunit = IfcUnitEnum.ELECTRICVOLTAGEUNIT + + +energyunit = IfcUnitEnum.ENERGYUNIT + + +forceunit = IfcUnitEnum.FORCEUNIT + + +frequencyunit = IfcUnitEnum.FREQUENCYUNIT + + +illuminanceunit = IfcUnitEnum.ILLUMINANCEUNIT + + +inductanceunit = IfcUnitEnum.INDUCTANCEUNIT + + +lengthunit = IfcUnitEnum.LENGTHUNIT + + +luminousfluxunit = IfcUnitEnum.LUMINOUSFLUXUNIT + + +luminousintensityunit = IfcUnitEnum.LUMINOUSINTENSITYUNIT + + +magneticfluxdensityunit = IfcUnitEnum.MAGNETICFLUXDENSITYUNIT + + +magneticfluxunit = IfcUnitEnum.MAGNETICFLUXUNIT + + +massunit = IfcUnitEnum.MASSUNIT + + +planeangleunit = IfcUnitEnum.PLANEANGLEUNIT + + +powerunit = IfcUnitEnum.POWERUNIT + + +pressureunit = IfcUnitEnum.PRESSUREUNIT + + +radioactivityunit = IfcUnitEnum.RADIOACTIVITYUNIT + + +solidangleunit = IfcUnitEnum.SOLIDANGLEUNIT + + +thermodynamictemperatureunit = IfcUnitEnum.THERMODYNAMICTEMPERATUREUNIT + + +timeunit = IfcUnitEnum.TIMEUNIT + + +volumeunit = IfcUnitEnum.VOLUMEUNIT + + +userdefined = IfcUnitEnum.USERDEFINED + + +IfcUnitaryControlElementTypeEnum = enum_namespace() + + +alarmpanel = IfcUnitaryControlElementTypeEnum.ALARMPANEL + + +controlpanel = IfcUnitaryControlElementTypeEnum.CONTROLPANEL + + +gasdetectionpanel = IfcUnitaryControlElementTypeEnum.GASDETECTIONPANEL + + +indicatorpanel = IfcUnitaryControlElementTypeEnum.INDICATORPANEL + + +mimicpanel = IfcUnitaryControlElementTypeEnum.MIMICPANEL + + +humidistat = IfcUnitaryControlElementTypeEnum.HUMIDISTAT + + +thermostat = IfcUnitaryControlElementTypeEnum.THERMOSTAT + + +weatherstation = IfcUnitaryControlElementTypeEnum.WEATHERSTATION + + +userdefined = IfcUnitaryControlElementTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryControlElementTypeEnum.NOTDEFINED + + +IfcUnitaryEquipmentTypeEnum = enum_namespace() + + +airhandler = IfcUnitaryEquipmentTypeEnum.AIRHANDLER + + +airconditioningunit = IfcUnitaryEquipmentTypeEnum.AIRCONDITIONINGUNIT + + +dehumidifier = IfcUnitaryEquipmentTypeEnum.DEHUMIDIFIER + + +splitsystem = IfcUnitaryEquipmentTypeEnum.SPLITSYSTEM + + +rooftopunit = IfcUnitaryEquipmentTypeEnum.ROOFTOPUNIT + + +userdefined = IfcUnitaryEquipmentTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryEquipmentTypeEnum.NOTDEFINED + + +IfcValveTypeEnum = enum_namespace() + + +airrelease = IfcValveTypeEnum.AIRRELEASE + + +antivacuum = IfcValveTypeEnum.ANTIVACUUM + + +changeover = IfcValveTypeEnum.CHANGEOVER + + +check = IfcValveTypeEnum.CHECK + + +commissioning = IfcValveTypeEnum.COMMISSIONING + + +diverting = IfcValveTypeEnum.DIVERTING + + +drawoffcock = IfcValveTypeEnum.DRAWOFFCOCK + + +doublecheck = IfcValveTypeEnum.DOUBLECHECK + + +doubleregulating = IfcValveTypeEnum.DOUBLEREGULATING + + +faucet = IfcValveTypeEnum.FAUCET + + +flushing = IfcValveTypeEnum.FLUSHING + + +gascock = IfcValveTypeEnum.GASCOCK + + +gastap = IfcValveTypeEnum.GASTAP + + +isolating = IfcValveTypeEnum.ISOLATING + + +mixing = IfcValveTypeEnum.MIXING + + +pressurereducing = IfcValveTypeEnum.PRESSUREREDUCING + + +pressurerelief = IfcValveTypeEnum.PRESSURERELIEF + + +regulating = IfcValveTypeEnum.REGULATING + + +safetycutoff = IfcValveTypeEnum.SAFETYCUTOFF + + +steamtrap = IfcValveTypeEnum.STEAMTRAP + + +stopcock = IfcValveTypeEnum.STOPCOCK + + +userdefined = IfcValveTypeEnum.USERDEFINED + + +notdefined = IfcValveTypeEnum.NOTDEFINED + + +IfcVibrationIsolatorTypeEnum = enum_namespace() + + +compression = IfcVibrationIsolatorTypeEnum.COMPRESSION + + +spring = IfcVibrationIsolatorTypeEnum.SPRING + + +userdefined = IfcVibrationIsolatorTypeEnum.USERDEFINED + + +notdefined = IfcVibrationIsolatorTypeEnum.NOTDEFINED + + +IfcVoidingFeatureTypeEnum = enum_namespace() + + +cutout = IfcVoidingFeatureTypeEnum.CUTOUT + + +notch = IfcVoidingFeatureTypeEnum.NOTCH + + +hole = IfcVoidingFeatureTypeEnum.HOLE + + +miter = IfcVoidingFeatureTypeEnum.MITER + + +chamfer = IfcVoidingFeatureTypeEnum.CHAMFER + + +edge = IfcVoidingFeatureTypeEnum.EDGE + + +userdefined = IfcVoidingFeatureTypeEnum.USERDEFINED + + +notdefined = IfcVoidingFeatureTypeEnum.NOTDEFINED + + +IfcWallTypeEnum = enum_namespace() + + +movable = IfcWallTypeEnum.MOVABLE + + +parapet = IfcWallTypeEnum.PARAPET + + +partitioning = IfcWallTypeEnum.PARTITIONING + + +plumbingwall = IfcWallTypeEnum.PLUMBINGWALL + + +shear = IfcWallTypeEnum.SHEAR + + +solidwall = IfcWallTypeEnum.SOLIDWALL + + +standard = IfcWallTypeEnum.STANDARD + + +polygonal = IfcWallTypeEnum.POLYGONAL + + +elementedwall = IfcWallTypeEnum.ELEMENTEDWALL + + +userdefined = IfcWallTypeEnum.USERDEFINED + + +notdefined = IfcWallTypeEnum.NOTDEFINED + + +IfcWasteTerminalTypeEnum = enum_namespace() + + +floortrap = IfcWasteTerminalTypeEnum.FLOORTRAP + + +floorwaste = IfcWasteTerminalTypeEnum.FLOORWASTE + + +gullysump = IfcWasteTerminalTypeEnum.GULLYSUMP + + +gullytrap = IfcWasteTerminalTypeEnum.GULLYTRAP + + +roofdrain = IfcWasteTerminalTypeEnum.ROOFDRAIN + + +wastedisposalunit = IfcWasteTerminalTypeEnum.WASTEDISPOSALUNIT + + +wastetrap = IfcWasteTerminalTypeEnum.WASTETRAP + + +userdefined = IfcWasteTerminalTypeEnum.USERDEFINED + + +notdefined = IfcWasteTerminalTypeEnum.NOTDEFINED + + +IfcWindowPanelOperationEnum = enum_namespace() + + +sidehungrighthand = IfcWindowPanelOperationEnum.SIDEHUNGRIGHTHAND + + +sidehunglefthand = IfcWindowPanelOperationEnum.SIDEHUNGLEFTHAND + + +tiltandturnrighthand = IfcWindowPanelOperationEnum.TILTANDTURNRIGHTHAND + + +tiltandturnlefthand = IfcWindowPanelOperationEnum.TILTANDTURNLEFTHAND + + +tophung = IfcWindowPanelOperationEnum.TOPHUNG + + +bottomhung = IfcWindowPanelOperationEnum.BOTTOMHUNG + + +pivothorizontal = IfcWindowPanelOperationEnum.PIVOTHORIZONTAL + + +pivotvertical = IfcWindowPanelOperationEnum.PIVOTVERTICAL + + +slidinghorizontal = IfcWindowPanelOperationEnum.SLIDINGHORIZONTAL + + +slidingvertical = IfcWindowPanelOperationEnum.SLIDINGVERTICAL + + +removablecasement = IfcWindowPanelOperationEnum.REMOVABLECASEMENT + + +fixedcasement = IfcWindowPanelOperationEnum.FIXEDCASEMENT + + +otheroperation = IfcWindowPanelOperationEnum.OTHEROPERATION + + +notdefined = IfcWindowPanelOperationEnum.NOTDEFINED + + +IfcWindowPanelPositionEnum = enum_namespace() + + +left = IfcWindowPanelPositionEnum.LEFT + + +middle = IfcWindowPanelPositionEnum.MIDDLE + + +right = IfcWindowPanelPositionEnum.RIGHT + + +bottom = IfcWindowPanelPositionEnum.BOTTOM + + +top = IfcWindowPanelPositionEnum.TOP + + +notdefined = IfcWindowPanelPositionEnum.NOTDEFINED + + +IfcWindowStyleConstructionEnum = enum_namespace() + + +aluminium = IfcWindowStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcWindowStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcWindowStyleConstructionEnum.STEEL + + +wood = IfcWindowStyleConstructionEnum.WOOD + + +aluminium_wood = IfcWindowStyleConstructionEnum.ALUMINIUM_WOOD + + +plastic = IfcWindowStyleConstructionEnum.PLASTIC + + +other_construction = IfcWindowStyleConstructionEnum.OTHER_CONSTRUCTION + + +notdefined = IfcWindowStyleConstructionEnum.NOTDEFINED + + +IfcWindowStyleOperationEnum = enum_namespace() + + +single_panel = IfcWindowStyleOperationEnum.SINGLE_PANEL + + +double_panel_vertical = IfcWindowStyleOperationEnum.DOUBLE_PANEL_VERTICAL + + +double_panel_horizontal = IfcWindowStyleOperationEnum.DOUBLE_PANEL_HORIZONTAL + + +triple_panel_vertical = IfcWindowStyleOperationEnum.TRIPLE_PANEL_VERTICAL + + +triple_panel_bottom = IfcWindowStyleOperationEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_top = IfcWindowStyleOperationEnum.TRIPLE_PANEL_TOP + + +triple_panel_left = IfcWindowStyleOperationEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowStyleOperationEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_horizontal = IfcWindowStyleOperationEnum.TRIPLE_PANEL_HORIZONTAL + + +userdefined = IfcWindowStyleOperationEnum.USERDEFINED + + +notdefined = IfcWindowStyleOperationEnum.NOTDEFINED + + +IfcWindowTypeEnum = enum_namespace() + + +window = IfcWindowTypeEnum.WINDOW + + +skylight = IfcWindowTypeEnum.SKYLIGHT + + +lightdome = IfcWindowTypeEnum.LIGHTDOME + + +userdefined = IfcWindowTypeEnum.USERDEFINED + + +notdefined = IfcWindowTypeEnum.NOTDEFINED + + +IfcWindowTypePartitioningEnum = enum_namespace() + + +single_panel = IfcWindowTypePartitioningEnum.SINGLE_PANEL + + +double_panel_vertical = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_VERTICAL + + +double_panel_horizontal = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_HORIZONTAL + + +triple_panel_vertical = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_VERTICAL + + +triple_panel_bottom = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_top = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_TOP + + +triple_panel_left = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_horizontal = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_HORIZONTAL + + +userdefined = IfcWindowTypePartitioningEnum.USERDEFINED + + +notdefined = IfcWindowTypePartitioningEnum.NOTDEFINED + + +IfcWorkCalendarTypeEnum = enum_namespace() + + +firstshift = IfcWorkCalendarTypeEnum.FIRSTSHIFT + + +secondshift = IfcWorkCalendarTypeEnum.SECONDSHIFT + + +thirdshift = IfcWorkCalendarTypeEnum.THIRDSHIFT + + +userdefined = IfcWorkCalendarTypeEnum.USERDEFINED + + +notdefined = IfcWorkCalendarTypeEnum.NOTDEFINED + + +IfcWorkPlanTypeEnum = enum_namespace() + + +actual = IfcWorkPlanTypeEnum.ACTUAL + + +baseline = IfcWorkPlanTypeEnum.BASELINE + + +planned = IfcWorkPlanTypeEnum.PLANNED + + +userdefined = IfcWorkPlanTypeEnum.USERDEFINED + + +notdefined = IfcWorkPlanTypeEnum.NOTDEFINED + + +IfcWorkScheduleTypeEnum = enum_namespace() + + +actual = IfcWorkScheduleTypeEnum.ACTUAL + + +baseline = IfcWorkScheduleTypeEnum.BASELINE + + +planned = IfcWorkScheduleTypeEnum.PLANNED + + +userdefined = IfcWorkScheduleTypeEnum.USERDEFINED + + +notdefined = IfcWorkScheduleTypeEnum.NOTDEFINED + + +def IfcActionRequest(*args, **kwargs): return ifcopenshell.create_entity('IfcActionRequest', 'IFC4', *args, **kwargs) + + +def IfcActor(*args, **kwargs): return ifcopenshell.create_entity('IfcActor', 'IFC4', *args, **kwargs) + + +def IfcActorRole(*args, **kwargs): return ifcopenshell.create_entity('IfcActorRole', 'IFC4', *args, **kwargs) + + +def IfcActuator(*args, **kwargs): return ifcopenshell.create_entity('IfcActuator', 'IFC4', *args, **kwargs) + + +def IfcActuatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcActuatorType', 'IFC4', *args, **kwargs) + + +def IfcAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcAddress', 'IFC4', *args, **kwargs) + + +def IfcAdvancedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrep', 'IFC4', *args, **kwargs) + + +def IfcAdvancedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrepWithVoids', 'IFC4', *args, **kwargs) + + +def IfcAdvancedFace(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedFace', 'IFC4', *args, **kwargs) + + +def IfcAirTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminal', 'IFC4', *args, **kwargs) + + +def IfcAirTerminalBox(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBox', 'IFC4', *args, **kwargs) + + +def IfcAirTerminalBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBoxType', 'IFC4', *args, **kwargs) + + +def IfcAirTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalType', 'IFC4', *args, **kwargs) + + +def IfcAirToAirHeatRecovery(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecovery', 'IFC4', *args, **kwargs) + + +def IfcAirToAirHeatRecoveryType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecoveryType', 'IFC4', *args, **kwargs) + + +def IfcAlarm(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarm', 'IFC4', *args, **kwargs) + + +def IfcAlarmType(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarmType', 'IFC4', *args, **kwargs) + + +def IfcAnnotation(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotation', 'IFC4', *args, **kwargs) + + +def IfcAnnotationFillArea(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationFillArea', 'IFC4', *args, **kwargs) + + +def IfcApplication(*args, **kwargs): return ifcopenshell.create_entity('IfcApplication', 'IFC4', *args, **kwargs) + + +def IfcAppliedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcAppliedValue', 'IFC4', *args, **kwargs) + + +def IfcApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcApproval', 'IFC4', *args, **kwargs) + + +def IfcApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcApprovalRelationship', 'IFC4', *args, **kwargs) + + +def IfcArbitraryClosedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryClosedProfileDef', 'IFC4', *args, **kwargs) + + +def IfcArbitraryOpenProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryOpenProfileDef', 'IFC4', *args, **kwargs) + + +def IfcArbitraryProfileDefWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryProfileDefWithVoids', 'IFC4', *args, **kwargs) + + +def IfcAsset(*args, **kwargs): return ifcopenshell.create_entity('IfcAsset', 'IFC4', *args, **kwargs) + + +def IfcAsymmetricIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcAsymmetricIShapeProfileDef', 'IFC4', *args, **kwargs) + + +def IfcAudioVisualAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualAppliance', 'IFC4', *args, **kwargs) + + +def IfcAudioVisualApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualApplianceType', 'IFC4', *args, **kwargs) + + +def IfcAxis1Placement(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis1Placement', 'IFC4', *args, **kwargs) + + +def IfcAxis2Placement2D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement2D', 'IFC4', *args, **kwargs) + + +def IfcAxis2Placement3D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement3D', 'IFC4', *args, **kwargs) + + +def IfcBSplineCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurve', 'IFC4', *args, **kwargs) + + +def IfcBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurveWithKnots', 'IFC4', *args, **kwargs) + + +def IfcBSplineSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurface', 'IFC4', *args, **kwargs) + + +def IfcBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurfaceWithKnots', 'IFC4', *args, **kwargs) + + +def IfcBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcBeam', 'IFC4', *args, **kwargs) + + +def IfcBeamStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamStandardCase', 'IFC4', *args, **kwargs) + + +def IfcBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamType', 'IFC4', *args, **kwargs) + + +def IfcBlobTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcBlobTexture', 'IFC4', *args, **kwargs) + + +def IfcBlock(*args, **kwargs): return ifcopenshell.create_entity('IfcBlock', 'IFC4', *args, **kwargs) + + +def IfcBoiler(*args, **kwargs): return ifcopenshell.create_entity('IfcBoiler', 'IFC4', *args, **kwargs) + + +def IfcBoilerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBoilerType', 'IFC4', *args, **kwargs) + + +def IfcBooleanClippingResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanClippingResult', 'IFC4', *args, **kwargs) + + +def IfcBooleanResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanResult', 'IFC4', *args, **kwargs) + + +def IfcBoundaryCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCondition', 'IFC4', *args, **kwargs) + + +def IfcBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCurve', 'IFC4', *args, **kwargs) + + +def IfcBoundaryEdgeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryEdgeCondition', 'IFC4', *args, **kwargs) + + +def IfcBoundaryFaceCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryFaceCondition', 'IFC4', *args, **kwargs) + + +def IfcBoundaryNodeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeCondition', 'IFC4', *args, **kwargs) + + +def IfcBoundaryNodeConditionWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeConditionWarping', 'IFC4', *args, **kwargs) + + +def IfcBoundedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedCurve', 'IFC4', *args, **kwargs) + + +def IfcBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedSurface', 'IFC4', *args, **kwargs) + + +def IfcBoundingBox(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundingBox', 'IFC4', *args, **kwargs) + + +def IfcBoxedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcBoxedHalfSpace', 'IFC4', *args, **kwargs) + + +def IfcBuilding(*args, **kwargs): return ifcopenshell.create_entity('IfcBuilding', 'IFC4', *args, **kwargs) + + +def IfcBuildingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElement', 'IFC4', *args, **kwargs) + + +def IfcBuildingElementPart(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPart', 'IFC4', *args, **kwargs) + + +def IfcBuildingElementPartType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPartType', 'IFC4', *args, **kwargs) + + +def IfcBuildingElementProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxy', 'IFC4', *args, **kwargs) + + +def IfcBuildingElementProxyType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxyType', 'IFC4', *args, **kwargs) + + +def IfcBuildingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementType', 'IFC4', *args, **kwargs) + + +def IfcBuildingStorey(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingStorey', 'IFC4', *args, **kwargs) + + +def IfcBuildingSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingSystem', 'IFC4', *args, **kwargs) + + +def IfcBurner(*args, **kwargs): return ifcopenshell.create_entity('IfcBurner', 'IFC4', *args, **kwargs) + + +def IfcBurnerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBurnerType', 'IFC4', *args, **kwargs) + + +def IfcCShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCShapeProfileDef', 'IFC4', *args, **kwargs) + + +def IfcCableCarrierFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFitting', 'IFC4', *args, **kwargs) + + +def IfcCableCarrierFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFittingType', 'IFC4', *args, **kwargs) + + +def IfcCableCarrierSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegment', 'IFC4', *args, **kwargs) + + +def IfcCableCarrierSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegmentType', 'IFC4', *args, **kwargs) + + +def IfcCableFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFitting', 'IFC4', *args, **kwargs) + + +def IfcCableFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFittingType', 'IFC4', *args, **kwargs) + + +def IfcCableSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegment', 'IFC4', *args, **kwargs) + + +def IfcCableSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegmentType', 'IFC4', *args, **kwargs) + + +def IfcCartesianPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPoint', 'IFC4', *args, **kwargs) + + +def IfcCartesianPointList(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList', 'IFC4', *args, **kwargs) + + +def IfcCartesianPointList2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList2D', 'IFC4', *args, **kwargs) + + +def IfcCartesianPointList3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList3D', 'IFC4', *args, **kwargs) + + +def IfcCartesianTransformationOperator(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator', 'IFC4', *args, **kwargs) + + +def IfcCartesianTransformationOperator2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2D', 'IFC4', *args, **kwargs) + + +def IfcCartesianTransformationOperator2DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2DnonUniform', 'IFC4', *args, **kwargs) + + +def IfcCartesianTransformationOperator3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3D', 'IFC4', *args, **kwargs) + + +def IfcCartesianTransformationOperator3DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3DnonUniform', 'IFC4', *args, **kwargs) + + +def IfcCenterLineProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCenterLineProfileDef', 'IFC4', *args, **kwargs) + + +def IfcChiller(*args, **kwargs): return ifcopenshell.create_entity('IfcChiller', 'IFC4', *args, **kwargs) + + +def IfcChillerType(*args, **kwargs): return ifcopenshell.create_entity('IfcChillerType', 'IFC4', *args, **kwargs) + + +def IfcChimney(*args, **kwargs): return ifcopenshell.create_entity('IfcChimney', 'IFC4', *args, **kwargs) + + +def IfcChimneyType(*args, **kwargs): return ifcopenshell.create_entity('IfcChimneyType', 'IFC4', *args, **kwargs) + + +def IfcCircle(*args, **kwargs): return ifcopenshell.create_entity('IfcCircle', 'IFC4', *args, **kwargs) + + +def IfcCircleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleHollowProfileDef', 'IFC4', *args, **kwargs) + + +def IfcCircleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleProfileDef', 'IFC4', *args, **kwargs) + + +def IfcCivilElement(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElement', 'IFC4', *args, **kwargs) + + +def IfcCivilElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElementType', 'IFC4', *args, **kwargs) + + +def IfcClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcClassification', 'IFC4', *args, **kwargs) + + +def IfcClassificationReference(*args, **kwargs): return ifcopenshell.create_entity('IfcClassificationReference', 'IFC4', *args, **kwargs) + + +def IfcClosedShell(*args, **kwargs): return ifcopenshell.create_entity('IfcClosedShell', 'IFC4', *args, **kwargs) + + +def IfcCoil(*args, **kwargs): return ifcopenshell.create_entity('IfcCoil', 'IFC4', *args, **kwargs) + + +def IfcCoilType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoilType', 'IFC4', *args, **kwargs) + + +def IfcColourRgb(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgb', 'IFC4', *args, **kwargs) + + +def IfcColourRgbList(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgbList', 'IFC4', *args, **kwargs) + + +def IfcColourSpecification(*args, **kwargs): return ifcopenshell.create_entity('IfcColourSpecification', 'IFC4', *args, **kwargs) + + +def IfcColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcColumn', 'IFC4', *args, **kwargs) + + +def IfcColumnStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnStandardCase', 'IFC4', *args, **kwargs) + + +def IfcColumnType(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnType', 'IFC4', *args, **kwargs) + + +def IfcCommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsAppliance', 'IFC4', *args, **kwargs) + + +def IfcCommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsApplianceType', 'IFC4', *args, **kwargs) + + +def IfcComplexProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexProperty', 'IFC4', *args, **kwargs) + + +def IfcComplexPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexPropertyTemplate', 'IFC4', *args, **kwargs) + + +def IfcCompositeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurve', 'IFC4', *args, **kwargs) + + +def IfcCompositeCurveOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveOnSurface', 'IFC4', *args, **kwargs) + + +def IfcCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveSegment', 'IFC4', *args, **kwargs) + + +def IfcCompositeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeProfileDef', 'IFC4', *args, **kwargs) + + +def IfcCompressor(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressor', 'IFC4', *args, **kwargs) + + +def IfcCompressorType(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressorType', 'IFC4', *args, **kwargs) + + +def IfcCondenser(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenser', 'IFC4', *args, **kwargs) + + +def IfcCondenserType(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenserType', 'IFC4', *args, **kwargs) + + +def IfcConic(*args, **kwargs): return ifcopenshell.create_entity('IfcConic', 'IFC4', *args, **kwargs) + + +def IfcConnectedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectedFaceSet', 'IFC4', *args, **kwargs) + + +def IfcConnectionCurveGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionCurveGeometry', 'IFC4', *args, **kwargs) + + +def IfcConnectionGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionGeometry', 'IFC4', *args, **kwargs) + + +def IfcConnectionPointEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointEccentricity', 'IFC4', *args, **kwargs) + + +def IfcConnectionPointGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointGeometry', 'IFC4', *args, **kwargs) + + +def IfcConnectionSurfaceGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionSurfaceGeometry', 'IFC4', *args, **kwargs) + + +def IfcConnectionVolumeGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionVolumeGeometry', 'IFC4', *args, **kwargs) + + +def IfcConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcConstraint', 'IFC4', *args, **kwargs) + + +def IfcConstructionEquipmentResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResource', 'IFC4', *args, **kwargs) + + +def IfcConstructionEquipmentResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResourceType', 'IFC4', *args, **kwargs) + + +def IfcConstructionMaterialResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResource', 'IFC4', *args, **kwargs) + + +def IfcConstructionMaterialResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResourceType', 'IFC4', *args, **kwargs) + + +def IfcConstructionProductResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResource', 'IFC4', *args, **kwargs) + + +def IfcConstructionProductResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResourceType', 'IFC4', *args, **kwargs) + + +def IfcConstructionResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResource', 'IFC4', *args, **kwargs) + + +def IfcConstructionResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResourceType', 'IFC4', *args, **kwargs) + + +def IfcContext(*args, **kwargs): return ifcopenshell.create_entity('IfcContext', 'IFC4', *args, **kwargs) + + +def IfcContextDependentUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcContextDependentUnit', 'IFC4', *args, **kwargs) + + +def IfcControl(*args, **kwargs): return ifcopenshell.create_entity('IfcControl', 'IFC4', *args, **kwargs) + + +def IfcController(*args, **kwargs): return ifcopenshell.create_entity('IfcController', 'IFC4', *args, **kwargs) + + +def IfcControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcControllerType', 'IFC4', *args, **kwargs) + + +def IfcConversionBasedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnit', 'IFC4', *args, **kwargs) + + +def IfcConversionBasedUnitWithOffset(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnitWithOffset', 'IFC4', *args, **kwargs) + + +def IfcCooledBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeam', 'IFC4', *args, **kwargs) + + +def IfcCooledBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeamType', 'IFC4', *args, **kwargs) + + +def IfcCoolingTower(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTower', 'IFC4', *args, **kwargs) + + +def IfcCoolingTowerType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTowerType', 'IFC4', *args, **kwargs) + + +def IfcCoordinateOperation(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateOperation', 'IFC4', *args, **kwargs) + + +def IfcCoordinateReferenceSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateReferenceSystem', 'IFC4', *args, **kwargs) + + +def IfcCostItem(*args, **kwargs): return ifcopenshell.create_entity('IfcCostItem', 'IFC4', *args, **kwargs) + + +def IfcCostSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcCostSchedule', 'IFC4', *args, **kwargs) + + +def IfcCostValue(*args, **kwargs): return ifcopenshell.create_entity('IfcCostValue', 'IFC4', *args, **kwargs) + + +def IfcCovering(*args, **kwargs): return ifcopenshell.create_entity('IfcCovering', 'IFC4', *args, **kwargs) + + +def IfcCoveringType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoveringType', 'IFC4', *args, **kwargs) + + +def IfcCrewResource(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResource', 'IFC4', *args, **kwargs) + + +def IfcCrewResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResourceType', 'IFC4', *args, **kwargs) + + +def IfcCsgPrimitive3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgPrimitive3D', 'IFC4', *args, **kwargs) + + +def IfcCsgSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgSolid', 'IFC4', *args, **kwargs) + + +def IfcCurrencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcCurrencyRelationship', 'IFC4', *args, **kwargs) + + +def IfcCurtainWall(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWall', 'IFC4', *args, **kwargs) + + +def IfcCurtainWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWallType', 'IFC4', *args, **kwargs) + + +def IfcCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCurve', 'IFC4', *args, **kwargs) + + +def IfcCurveBoundedPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedPlane', 'IFC4', *args, **kwargs) + + +def IfcCurveBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedSurface', 'IFC4', *args, **kwargs) + + +def IfcCurveStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyle', 'IFC4', *args, **kwargs) + + +def IfcCurveStyleFont(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFont', 'IFC4', *args, **kwargs) + + +def IfcCurveStyleFontAndScaling(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontAndScaling', 'IFC4', *args, **kwargs) + + +def IfcCurveStyleFontPattern(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontPattern', 'IFC4', *args, **kwargs) + + +def IfcCylindricalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCylindricalSurface', 'IFC4', *args, **kwargs) + + +def IfcDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcDamper', 'IFC4', *args, **kwargs) + + +def IfcDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcDamperType', 'IFC4', *args, **kwargs) + + +def IfcDerivedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedProfileDef', 'IFC4', *args, **kwargs) + + +def IfcDerivedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnit', 'IFC4', *args, **kwargs) + + +def IfcDerivedUnitElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnitElement', 'IFC4', *args, **kwargs) + + +def IfcDimensionalExponents(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionalExponents', 'IFC4', *args, **kwargs) + + +def IfcDirection(*args, **kwargs): return ifcopenshell.create_entity('IfcDirection', 'IFC4', *args, **kwargs) + + +def IfcDiscreteAccessory(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessory', 'IFC4', *args, **kwargs) + + +def IfcDiscreteAccessoryType(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessoryType', 'IFC4', *args, **kwargs) + + +def IfcDistributionChamberElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElement', 'IFC4', *args, **kwargs) + + +def IfcDistributionChamberElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElementType', 'IFC4', *args, **kwargs) + + +def IfcDistributionCircuit(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionCircuit', 'IFC4', *args, **kwargs) + + +def IfcDistributionControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElement', 'IFC4', *args, **kwargs) + + +def IfcDistributionControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElementType', 'IFC4', *args, **kwargs) + + +def IfcDistributionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElement', 'IFC4', *args, **kwargs) + + +def IfcDistributionElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElementType', 'IFC4', *args, **kwargs) + + +def IfcDistributionFlowElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElement', 'IFC4', *args, **kwargs) + + +def IfcDistributionFlowElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElementType', 'IFC4', *args, **kwargs) + + +def IfcDistributionPort(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionPort', 'IFC4', *args, **kwargs) + + +def IfcDistributionSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionSystem', 'IFC4', *args, **kwargs) + + +def IfcDocumentInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformation', 'IFC4', *args, **kwargs) + + +def IfcDocumentInformationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformationRelationship', 'IFC4', *args, **kwargs) + + +def IfcDocumentReference(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentReference', 'IFC4', *args, **kwargs) + + +def IfcDoor(*args, **kwargs): return ifcopenshell.create_entity('IfcDoor', 'IFC4', *args, **kwargs) + + +def IfcDoorLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorLiningProperties', 'IFC4', *args, **kwargs) + + +def IfcDoorPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorPanelProperties', 'IFC4', *args, **kwargs) + + +def IfcDoorStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorStandardCase', 'IFC4', *args, **kwargs) + + +def IfcDoorStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorStyle', 'IFC4', *args, **kwargs) + + +def IfcDoorType(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorType', 'IFC4', *args, **kwargs) + + +def IfcDraughtingPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedColour', 'IFC4', *args, **kwargs) + + +def IfcDraughtingPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedCurveFont', 'IFC4', *args, **kwargs) + + +def IfcDuctFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFitting', 'IFC4', *args, **kwargs) + + +def IfcDuctFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFittingType', 'IFC4', *args, **kwargs) + + +def IfcDuctSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegment', 'IFC4', *args, **kwargs) + + +def IfcDuctSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegmentType', 'IFC4', *args, **kwargs) + + +def IfcDuctSilencer(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencer', 'IFC4', *args, **kwargs) + + +def IfcDuctSilencerType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencerType', 'IFC4', *args, **kwargs) + + +def IfcEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcEdge', 'IFC4', *args, **kwargs) + + +def IfcEdgeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeCurve', 'IFC4', *args, **kwargs) + + +def IfcEdgeLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeLoop', 'IFC4', *args, **kwargs) + + +def IfcElectricAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricAppliance', 'IFC4', *args, **kwargs) + + +def IfcElectricApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricApplianceType', 'IFC4', *args, **kwargs) + + +def IfcElectricDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoard', 'IFC4', *args, **kwargs) + + +def IfcElectricDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoardType', 'IFC4', *args, **kwargs) + + +def IfcElectricFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDevice', 'IFC4', *args, **kwargs) + + +def IfcElectricFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDeviceType', 'IFC4', *args, **kwargs) + + +def IfcElectricGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGenerator', 'IFC4', *args, **kwargs) + + +def IfcElectricGeneratorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGeneratorType', 'IFC4', *args, **kwargs) + + +def IfcElectricMotor(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotor', 'IFC4', *args, **kwargs) + + +def IfcElectricMotorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotorType', 'IFC4', *args, **kwargs) + + +def IfcElectricTimeControl(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControl', 'IFC4', *args, **kwargs) + + +def IfcElectricTimeControlType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControlType', 'IFC4', *args, **kwargs) + + +def IfcElement(*args, **kwargs): return ifcopenshell.create_entity('IfcElement', 'IFC4', *args, **kwargs) + + +def IfcElementAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssembly', 'IFC4', *args, **kwargs) + + +def IfcElementAssemblyType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssemblyType', 'IFC4', *args, **kwargs) + + +def IfcElementComponent(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponent', 'IFC4', *args, **kwargs) + + +def IfcElementComponentType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponentType', 'IFC4', *args, **kwargs) + + +def IfcElementQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcElementQuantity', 'IFC4', *args, **kwargs) + + +def IfcElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementType', 'IFC4', *args, **kwargs) + + +def IfcElementarySurface(*args, **kwargs): return ifcopenshell.create_entity('IfcElementarySurface', 'IFC4', *args, **kwargs) + + +def IfcEllipse(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipse', 'IFC4', *args, **kwargs) + + +def IfcEllipseProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipseProfileDef', 'IFC4', *args, **kwargs) + + +def IfcEnergyConversionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDevice', 'IFC4', *args, **kwargs) + + +def IfcEnergyConversionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDeviceType', 'IFC4', *args, **kwargs) + + +def IfcEngine(*args, **kwargs): return ifcopenshell.create_entity('IfcEngine', 'IFC4', *args, **kwargs) + + +def IfcEngineType(*args, **kwargs): return ifcopenshell.create_entity('IfcEngineType', 'IFC4', *args, **kwargs) + + +def IfcEvaporativeCooler(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCooler', 'IFC4', *args, **kwargs) + + +def IfcEvaporativeCoolerType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCoolerType', 'IFC4', *args, **kwargs) + + +def IfcEvaporator(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporator', 'IFC4', *args, **kwargs) + + +def IfcEvaporatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporatorType', 'IFC4', *args, **kwargs) + + +def IfcEvent(*args, **kwargs): return ifcopenshell.create_entity('IfcEvent', 'IFC4', *args, **kwargs) + + +def IfcEventTime(*args, **kwargs): return ifcopenshell.create_entity('IfcEventTime', 'IFC4', *args, **kwargs) + + +def IfcEventType(*args, **kwargs): return ifcopenshell.create_entity('IfcEventType', 'IFC4', *args, **kwargs) + + +def IfcExtendedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcExtendedProperties', 'IFC4', *args, **kwargs) + + +def IfcExternalInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalInformation', 'IFC4', *args, **kwargs) + + +def IfcExternalReference(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReference', 'IFC4', *args, **kwargs) + + +def IfcExternalReferenceRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReferenceRelationship', 'IFC4', *args, **kwargs) + + +def IfcExternalSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialElement', 'IFC4', *args, **kwargs) + + +def IfcExternalSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialStructureElement', 'IFC4', *args, **kwargs) + + +def IfcExternallyDefinedHatchStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedHatchStyle', 'IFC4', *args, **kwargs) + + +def IfcExternallyDefinedSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedSurfaceStyle', 'IFC4', *args, **kwargs) + + +def IfcExternallyDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedTextFont', 'IFC4', *args, **kwargs) + + +def IfcExtrudedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolid', 'IFC4', *args, **kwargs) + + +def IfcExtrudedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolidTapered', 'IFC4', *args, **kwargs) + + +def IfcFace(*args, **kwargs): return ifcopenshell.create_entity('IfcFace', 'IFC4', *args, **kwargs) + + +def IfcFaceBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBasedSurfaceModel', 'IFC4', *args, **kwargs) + + +def IfcFaceBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBound', 'IFC4', *args, **kwargs) + + +def IfcFaceOuterBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceOuterBound', 'IFC4', *args, **kwargs) + + +def IfcFaceSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceSurface', 'IFC4', *args, **kwargs) + + +def IfcFacetedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrep', 'IFC4', *args, **kwargs) + + +def IfcFacetedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrepWithVoids', 'IFC4', *args, **kwargs) + + +def IfcFailureConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcFailureConnectionCondition', 'IFC4', *args, **kwargs) + + +def IfcFan(*args, **kwargs): return ifcopenshell.create_entity('IfcFan', 'IFC4', *args, **kwargs) + + +def IfcFanType(*args, **kwargs): return ifcopenshell.create_entity('IfcFanType', 'IFC4', *args, **kwargs) + + +def IfcFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcFastener', 'IFC4', *args, **kwargs) + + +def IfcFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFastenerType', 'IFC4', *args, **kwargs) + + +def IfcFeatureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElement', 'IFC4', *args, **kwargs) + + +def IfcFeatureElementAddition(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementAddition', 'IFC4', *args, **kwargs) + + +def IfcFeatureElementSubtraction(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementSubtraction', 'IFC4', *args, **kwargs) + + +def IfcFillAreaStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyle', 'IFC4', *args, **kwargs) + + +def IfcFillAreaStyleHatching(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleHatching', 'IFC4', *args, **kwargs) + + +def IfcFillAreaStyleTiles(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleTiles', 'IFC4', *args, **kwargs) + + +def IfcFilter(*args, **kwargs): return ifcopenshell.create_entity('IfcFilter', 'IFC4', *args, **kwargs) + + +def IfcFilterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFilterType', 'IFC4', *args, **kwargs) + + +def IfcFireSuppressionTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminal', 'IFC4', *args, **kwargs) + + +def IfcFireSuppressionTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminalType', 'IFC4', *args, **kwargs) + + +def IfcFixedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcFixedReferenceSweptAreaSolid', 'IFC4', *args, **kwargs) + + +def IfcFlowController(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowController', 'IFC4', *args, **kwargs) + + +def IfcFlowControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowControllerType', 'IFC4', *args, **kwargs) + + +def IfcFlowFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFitting', 'IFC4', *args, **kwargs) + + +def IfcFlowFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFittingType', 'IFC4', *args, **kwargs) + + +def IfcFlowInstrument(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrument', 'IFC4', *args, **kwargs) + + +def IfcFlowInstrumentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrumentType', 'IFC4', *args, **kwargs) + + +def IfcFlowMeter(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeter', 'IFC4', *args, **kwargs) + + +def IfcFlowMeterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeterType', 'IFC4', *args, **kwargs) + + +def IfcFlowMovingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDevice', 'IFC4', *args, **kwargs) + + +def IfcFlowMovingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDeviceType', 'IFC4', *args, **kwargs) + + +def IfcFlowSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegment', 'IFC4', *args, **kwargs) + + +def IfcFlowSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegmentType', 'IFC4', *args, **kwargs) + + +def IfcFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDevice', 'IFC4', *args, **kwargs) + + +def IfcFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDeviceType', 'IFC4', *args, **kwargs) + + +def IfcFlowTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminal', 'IFC4', *args, **kwargs) + + +def IfcFlowTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminalType', 'IFC4', *args, **kwargs) + + +def IfcFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDevice', 'IFC4', *args, **kwargs) + + +def IfcFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDeviceType', 'IFC4', *args, **kwargs) + + +def IfcFooting(*args, **kwargs): return ifcopenshell.create_entity('IfcFooting', 'IFC4', *args, **kwargs) + + +def IfcFootingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFootingType', 'IFC4', *args, **kwargs) + + +def IfcFurnishingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElement', 'IFC4', *args, **kwargs) + + +def IfcFurnishingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElementType', 'IFC4', *args, **kwargs) + + +def IfcFurniture(*args, **kwargs): return ifcopenshell.create_entity('IfcFurniture', 'IFC4', *args, **kwargs) + + +def IfcFurnitureType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnitureType', 'IFC4', *args, **kwargs) + + +def IfcGeographicElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElement', 'IFC4', *args, **kwargs) + + +def IfcGeographicElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElementType', 'IFC4', *args, **kwargs) + + +def IfcGeometricCurveSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricCurveSet', 'IFC4', *args, **kwargs) + + +def IfcGeometricRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationContext', 'IFC4', *args, **kwargs) + + +def IfcGeometricRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationItem', 'IFC4', *args, **kwargs) + + +def IfcGeometricRepresentationSubContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationSubContext', 'IFC4', *args, **kwargs) + + +def IfcGeometricSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricSet', 'IFC4', *args, **kwargs) + + +def IfcGrid(*args, **kwargs): return ifcopenshell.create_entity('IfcGrid', 'IFC4', *args, **kwargs) + + +def IfcGridAxis(*args, **kwargs): return ifcopenshell.create_entity('IfcGridAxis', 'IFC4', *args, **kwargs) + + +def IfcGridPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcGridPlacement', 'IFC4', *args, **kwargs) + + +def IfcGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcGroup', 'IFC4', *args, **kwargs) + + +def IfcHalfSpaceSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcHalfSpaceSolid', 'IFC4', *args, **kwargs) + + +def IfcHeatExchanger(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchanger', 'IFC4', *args, **kwargs) + + +def IfcHeatExchangerType(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchangerType', 'IFC4', *args, **kwargs) + + +def IfcHumidifier(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifier', 'IFC4', *args, **kwargs) + + +def IfcHumidifierType(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifierType', 'IFC4', *args, **kwargs) + + +def IfcIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcIShapeProfileDef', 'IFC4', *args, **kwargs) + + +def IfcImageTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcImageTexture', 'IFC4', *args, **kwargs) + + +def IfcIndexedColourMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedColourMap', 'IFC4', *args, **kwargs) + + +def IfcIndexedPolyCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolyCurve', 'IFC4', *args, **kwargs) + + +def IfcIndexedPolygonalFace(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFace', 'IFC4', *args, **kwargs) + + +def IfcIndexedPolygonalFaceWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFaceWithVoids', 'IFC4', *args, **kwargs) + + +def IfcIndexedTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTextureMap', 'IFC4', *args, **kwargs) + + +def IfcIndexedTriangleTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTriangleTextureMap', 'IFC4', *args, **kwargs) + + +def IfcInterceptor(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptor', 'IFC4', *args, **kwargs) + + +def IfcInterceptorType(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptorType', 'IFC4', *args, **kwargs) + + +def IfcIntersectionCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIntersectionCurve', 'IFC4', *args, **kwargs) + + +def IfcInventory(*args, **kwargs): return ifcopenshell.create_entity('IfcInventory', 'IFC4', *args, **kwargs) + + +def IfcIrregularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeries', 'IFC4', *args, **kwargs) + + +def IfcIrregularTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeriesValue', 'IFC4', *args, **kwargs) + + +def IfcJunctionBox(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBox', 'IFC4', *args, **kwargs) + + +def IfcJunctionBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBoxType', 'IFC4', *args, **kwargs) + + +def IfcLShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcLShapeProfileDef', 'IFC4', *args, **kwargs) + + +def IfcLaborResource(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResource', 'IFC4', *args, **kwargs) + + +def IfcLaborResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResourceType', 'IFC4', *args, **kwargs) + + +def IfcLagTime(*args, **kwargs): return ifcopenshell.create_entity('IfcLagTime', 'IFC4', *args, **kwargs) + + +def IfcLamp(*args, **kwargs): return ifcopenshell.create_entity('IfcLamp', 'IFC4', *args, **kwargs) + + +def IfcLampType(*args, **kwargs): return ifcopenshell.create_entity('IfcLampType', 'IFC4', *args, **kwargs) + + +def IfcLibraryInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryInformation', 'IFC4', *args, **kwargs) + + +def IfcLibraryReference(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryReference', 'IFC4', *args, **kwargs) + + +def IfcLightDistributionData(*args, **kwargs): return ifcopenshell.create_entity('IfcLightDistributionData', 'IFC4', *args, **kwargs) + + +def IfcLightFixture(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixture', 'IFC4', *args, **kwargs) + + +def IfcLightFixtureType(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixtureType', 'IFC4', *args, **kwargs) + + +def IfcLightIntensityDistribution(*args, **kwargs): return ifcopenshell.create_entity('IfcLightIntensityDistribution', 'IFC4', *args, **kwargs) + + +def IfcLightSource(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSource', 'IFC4', *args, **kwargs) + + +def IfcLightSourceAmbient(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceAmbient', 'IFC4', *args, **kwargs) + + +def IfcLightSourceDirectional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceDirectional', 'IFC4', *args, **kwargs) + + +def IfcLightSourceGoniometric(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceGoniometric', 'IFC4', *args, **kwargs) + + +def IfcLightSourcePositional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourcePositional', 'IFC4', *args, **kwargs) + + +def IfcLightSourceSpot(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceSpot', 'IFC4', *args, **kwargs) + + +def IfcLine(*args, **kwargs): return ifcopenshell.create_entity('IfcLine', 'IFC4', *args, **kwargs) + + +def IfcLocalPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLocalPlacement', 'IFC4', *args, **kwargs) + + +def IfcLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcLoop', 'IFC4', *args, **kwargs) + + +def IfcManifoldSolidBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcManifoldSolidBrep', 'IFC4', *args, **kwargs) + + +def IfcMapConversion(*args, **kwargs): return ifcopenshell.create_entity('IfcMapConversion', 'IFC4', *args, **kwargs) + + +def IfcMappedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcMappedItem', 'IFC4', *args, **kwargs) + + +def IfcMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterial', 'IFC4', *args, **kwargs) + + +def IfcMaterialClassificationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialClassificationRelationship', 'IFC4', *args, **kwargs) + + +def IfcMaterialConstituent(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituent', 'IFC4', *args, **kwargs) + + +def IfcMaterialConstituentSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituentSet', 'IFC4', *args, **kwargs) + + +def IfcMaterialDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinition', 'IFC4', *args, **kwargs) + + +def IfcMaterialDefinitionRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinitionRepresentation', 'IFC4', *args, **kwargs) + + +def IfcMaterialLayer(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayer', 'IFC4', *args, **kwargs) + + +def IfcMaterialLayerSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSet', 'IFC4', *args, **kwargs) + + +def IfcMaterialLayerSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSetUsage', 'IFC4', *args, **kwargs) + + +def IfcMaterialLayerWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerWithOffsets', 'IFC4', *args, **kwargs) + + +def IfcMaterialList(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialList', 'IFC4', *args, **kwargs) + + +def IfcMaterialProfile(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfile', 'IFC4', *args, **kwargs) + + +def IfcMaterialProfileSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSet', 'IFC4', *args, **kwargs) + + +def IfcMaterialProfileSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsage', 'IFC4', *args, **kwargs) + + +def IfcMaterialProfileSetUsageTapering(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsageTapering', 'IFC4', *args, **kwargs) + + +def IfcMaterialProfileWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileWithOffsets', 'IFC4', *args, **kwargs) + + +def IfcMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProperties', 'IFC4', *args, **kwargs) + + +def IfcMaterialRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialRelationship', 'IFC4', *args, **kwargs) + + +def IfcMaterialUsageDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialUsageDefinition', 'IFC4', *args, **kwargs) + + +def IfcMeasureWithUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMeasureWithUnit', 'IFC4', *args, **kwargs) + + +def IfcMechanicalFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastener', 'IFC4', *args, **kwargs) + + +def IfcMechanicalFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastenerType', 'IFC4', *args, **kwargs) + + +def IfcMedicalDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDevice', 'IFC4', *args, **kwargs) + + +def IfcMedicalDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDeviceType', 'IFC4', *args, **kwargs) + + +def IfcMember(*args, **kwargs): return ifcopenshell.create_entity('IfcMember', 'IFC4', *args, **kwargs) + + +def IfcMemberStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberStandardCase', 'IFC4', *args, **kwargs) + + +def IfcMemberType(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberType', 'IFC4', *args, **kwargs) + + +def IfcMetric(*args, **kwargs): return ifcopenshell.create_entity('IfcMetric', 'IFC4', *args, **kwargs) + + +def IfcMirroredProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcMirroredProfileDef', 'IFC4', *args, **kwargs) + + +def IfcMonetaryUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMonetaryUnit', 'IFC4', *args, **kwargs) + + +def IfcMotorConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnection', 'IFC4', *args, **kwargs) + + +def IfcMotorConnectionType(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnectionType', 'IFC4', *args, **kwargs) + + +def IfcNamedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcNamedUnit', 'IFC4', *args, **kwargs) + + +def IfcObject(*args, **kwargs): return ifcopenshell.create_entity('IfcObject', 'IFC4', *args, **kwargs) + + +def IfcObjectDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectDefinition', 'IFC4', *args, **kwargs) + + +def IfcObjectPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectPlacement', 'IFC4', *args, **kwargs) + + +def IfcObjective(*args, **kwargs): return ifcopenshell.create_entity('IfcObjective', 'IFC4', *args, **kwargs) + + +def IfcOccupant(*args, **kwargs): return ifcopenshell.create_entity('IfcOccupant', 'IFC4', *args, **kwargs) + + +def IfcOffsetCurve2D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve2D', 'IFC4', *args, **kwargs) + + +def IfcOffsetCurve3D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve3D', 'IFC4', *args, **kwargs) + + +def IfcOpenShell(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenShell', 'IFC4', *args, **kwargs) + + +def IfcOpeningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningElement', 'IFC4', *args, **kwargs) + + +def IfcOpeningStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningStandardCase', 'IFC4', *args, **kwargs) + + +def IfcOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganization', 'IFC4', *args, **kwargs) + + +def IfcOrganizationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganizationRelationship', 'IFC4', *args, **kwargs) + + +def IfcOrientedEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcOrientedEdge', 'IFC4', *args, **kwargs) + + +def IfcOuterBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOuterBoundaryCurve', 'IFC4', *args, **kwargs) + + +def IfcOutlet(*args, **kwargs): return ifcopenshell.create_entity('IfcOutlet', 'IFC4', *args, **kwargs) + + +def IfcOutletType(*args, **kwargs): return ifcopenshell.create_entity('IfcOutletType', 'IFC4', *args, **kwargs) + + +def IfcOwnerHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcOwnerHistory', 'IFC4', *args, **kwargs) + + +def IfcParameterizedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcParameterizedProfileDef', 'IFC4', *args, **kwargs) + + +def IfcPath(*args, **kwargs): return ifcopenshell.create_entity('IfcPath', 'IFC4', *args, **kwargs) + + +def IfcPcurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPcurve', 'IFC4', *args, **kwargs) + + +def IfcPerformanceHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcPerformanceHistory', 'IFC4', *args, **kwargs) + + +def IfcPermeableCoveringProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPermeableCoveringProperties', 'IFC4', *args, **kwargs) + + +def IfcPermit(*args, **kwargs): return ifcopenshell.create_entity('IfcPermit', 'IFC4', *args, **kwargs) + + +def IfcPerson(*args, **kwargs): return ifcopenshell.create_entity('IfcPerson', 'IFC4', *args, **kwargs) + + +def IfcPersonAndOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcPersonAndOrganization', 'IFC4', *args, **kwargs) + + +def IfcPhysicalComplexQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalComplexQuantity', 'IFC4', *args, **kwargs) + + +def IfcPhysicalQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalQuantity', 'IFC4', *args, **kwargs) + + +def IfcPhysicalSimpleQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalSimpleQuantity', 'IFC4', *args, **kwargs) + + +def IfcPile(*args, **kwargs): return ifcopenshell.create_entity('IfcPile', 'IFC4', *args, **kwargs) + + +def IfcPileType(*args, **kwargs): return ifcopenshell.create_entity('IfcPileType', 'IFC4', *args, **kwargs) + + +def IfcPipeFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFitting', 'IFC4', *args, **kwargs) + + +def IfcPipeFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFittingType', 'IFC4', *args, **kwargs) + + +def IfcPipeSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegment', 'IFC4', *args, **kwargs) + + +def IfcPipeSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegmentType', 'IFC4', *args, **kwargs) + + +def IfcPixelTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcPixelTexture', 'IFC4', *args, **kwargs) + + +def IfcPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcPlacement', 'IFC4', *args, **kwargs) + + +def IfcPlanarBox(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarBox', 'IFC4', *args, **kwargs) + + +def IfcPlanarExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarExtent', 'IFC4', *args, **kwargs) + + +def IfcPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcPlane', 'IFC4', *args, **kwargs) + + +def IfcPlate(*args, **kwargs): return ifcopenshell.create_entity('IfcPlate', 'IFC4', *args, **kwargs) + + +def IfcPlateStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateStandardCase', 'IFC4', *args, **kwargs) + + +def IfcPlateType(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateType', 'IFC4', *args, **kwargs) + + +def IfcPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcPoint', 'IFC4', *args, **kwargs) + + +def IfcPointOnCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnCurve', 'IFC4', *args, **kwargs) + + +def IfcPointOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnSurface', 'IFC4', *args, **kwargs) + + +def IfcPolyLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyLoop', 'IFC4', *args, **kwargs) + + +def IfcPolygonalBoundedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalBoundedHalfSpace', 'IFC4', *args, **kwargs) + + +def IfcPolygonalFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalFaceSet', 'IFC4', *args, **kwargs) + + +def IfcPolyline(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyline', 'IFC4', *args, **kwargs) + + +def IfcPort(*args, **kwargs): return ifcopenshell.create_entity('IfcPort', 'IFC4', *args, **kwargs) + + +def IfcPostalAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcPostalAddress', 'IFC4', *args, **kwargs) + + +def IfcPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedColour', 'IFC4', *args, **kwargs) + + +def IfcPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedCurveFont', 'IFC4', *args, **kwargs) + + +def IfcPreDefinedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedItem', 'IFC4', *args, **kwargs) + + +def IfcPreDefinedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedProperties', 'IFC4', *args, **kwargs) + + +def IfcPreDefinedPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedPropertySet', 'IFC4', *args, **kwargs) + + +def IfcPreDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedTextFont', 'IFC4', *args, **kwargs) + + +def IfcPresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationItem', 'IFC4', *args, **kwargs) + + +def IfcPresentationLayerAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerAssignment', 'IFC4', *args, **kwargs) + + +def IfcPresentationLayerWithStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerWithStyle', 'IFC4', *args, **kwargs) + + +def IfcPresentationStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyle', 'IFC4', *args, **kwargs) + + +def IfcPresentationStyleAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyleAssignment', 'IFC4', *args, **kwargs) + + +def IfcProcedure(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedure', 'IFC4', *args, **kwargs) + + +def IfcProcedureType(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedureType', 'IFC4', *args, **kwargs) + + +def IfcProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcProcess', 'IFC4', *args, **kwargs) + + +def IfcProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcProduct', 'IFC4', *args, **kwargs) + + +def IfcProductDefinitionShape(*args, **kwargs): return ifcopenshell.create_entity('IfcProductDefinitionShape', 'IFC4', *args, **kwargs) + + +def IfcProductRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcProductRepresentation', 'IFC4', *args, **kwargs) + + +def IfcProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileDef', 'IFC4', *args, **kwargs) + + +def IfcProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileProperties', 'IFC4', *args, **kwargs) + + +def IfcProject(*args, **kwargs): return ifcopenshell.create_entity('IfcProject', 'IFC4', *args, **kwargs) + + +def IfcProjectLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectLibrary', 'IFC4', *args, **kwargs) + + +def IfcProjectOrder(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectOrder', 'IFC4', *args, **kwargs) + + +def IfcProjectedCRS(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectedCRS', 'IFC4', *args, **kwargs) + + +def IfcProjectionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectionElement', 'IFC4', *args, **kwargs) + + +def IfcProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcProperty', 'IFC4', *args, **kwargs) + + +def IfcPropertyAbstraction(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyAbstraction', 'IFC4', *args, **kwargs) + + +def IfcPropertyBoundedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyBoundedValue', 'IFC4', *args, **kwargs) + + +def IfcPropertyDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDefinition', 'IFC4', *args, **kwargs) + + +def IfcPropertyDependencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDependencyRelationship', 'IFC4', *args, **kwargs) + + +def IfcPropertyEnumeratedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeratedValue', 'IFC4', *args, **kwargs) + + +def IfcPropertyEnumeration(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeration', 'IFC4', *args, **kwargs) + + +def IfcPropertyListValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyListValue', 'IFC4', *args, **kwargs) + + +def IfcPropertyReferenceValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyReferenceValue', 'IFC4', *args, **kwargs) + + +def IfcPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySet', 'IFC4', *args, **kwargs) + + +def IfcPropertySetDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetDefinition', 'IFC4', *args, **kwargs) + + +def IfcPropertySetTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetTemplate', 'IFC4', *args, **kwargs) + + +def IfcPropertySingleValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySingleValue', 'IFC4', *args, **kwargs) + + +def IfcPropertyTableValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTableValue', 'IFC4', *args, **kwargs) + + +def IfcPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplate', 'IFC4', *args, **kwargs) + + +def IfcPropertyTemplateDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplateDefinition', 'IFC4', *args, **kwargs) + + +def IfcProtectiveDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDevice', 'IFC4', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnit', 'IFC4', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnitType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnitType', 'IFC4', *args, **kwargs) + + +def IfcProtectiveDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceType', 'IFC4', *args, **kwargs) + + +def IfcProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcProxy', 'IFC4', *args, **kwargs) + + +def IfcPump(*args, **kwargs): return ifcopenshell.create_entity('IfcPump', 'IFC4', *args, **kwargs) + + +def IfcPumpType(*args, **kwargs): return ifcopenshell.create_entity('IfcPumpType', 'IFC4', *args, **kwargs) + + +def IfcQuantityArea(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityArea', 'IFC4', *args, **kwargs) + + +def IfcQuantityCount(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityCount', 'IFC4', *args, **kwargs) + + +def IfcQuantityLength(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityLength', 'IFC4', *args, **kwargs) + + +def IfcQuantitySet(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantitySet', 'IFC4', *args, **kwargs) + + +def IfcQuantityTime(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityTime', 'IFC4', *args, **kwargs) + + +def IfcQuantityVolume(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityVolume', 'IFC4', *args, **kwargs) + + +def IfcQuantityWeight(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityWeight', 'IFC4', *args, **kwargs) + + +def IfcRailing(*args, **kwargs): return ifcopenshell.create_entity('IfcRailing', 'IFC4', *args, **kwargs) + + +def IfcRailingType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailingType', 'IFC4', *args, **kwargs) + + +def IfcRamp(*args, **kwargs): return ifcopenshell.create_entity('IfcRamp', 'IFC4', *args, **kwargs) + + +def IfcRampFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlight', 'IFC4', *args, **kwargs) + + +def IfcRampFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlightType', 'IFC4', *args, **kwargs) + + +def IfcRampType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampType', 'IFC4', *args, **kwargs) + + +def IfcRationalBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineCurveWithKnots', 'IFC4', *args, **kwargs) + + +def IfcRationalBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineSurfaceWithKnots', 'IFC4', *args, **kwargs) + + +def IfcRectangleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleHollowProfileDef', 'IFC4', *args, **kwargs) + + +def IfcRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleProfileDef', 'IFC4', *args, **kwargs) + + +def IfcRectangularPyramid(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularPyramid', 'IFC4', *args, **kwargs) + + +def IfcRectangularTrimmedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularTrimmedSurface', 'IFC4', *args, **kwargs) + + +def IfcRecurrencePattern(*args, **kwargs): return ifcopenshell.create_entity('IfcRecurrencePattern', 'IFC4', *args, **kwargs) + + +def IfcReference(*args, **kwargs): return ifcopenshell.create_entity('IfcReference', 'IFC4', *args, **kwargs) + + +def IfcRegularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcRegularTimeSeries', 'IFC4', *args, **kwargs) + + +def IfcReinforcementBarProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementBarProperties', 'IFC4', *args, **kwargs) + + +def IfcReinforcementDefinitionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementDefinitionProperties', 'IFC4', *args, **kwargs) + + +def IfcReinforcingBar(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBar', 'IFC4', *args, **kwargs) + + +def IfcReinforcingBarType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBarType', 'IFC4', *args, **kwargs) + + +def IfcReinforcingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElement', 'IFC4', *args, **kwargs) + + +def IfcReinforcingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElementType', 'IFC4', *args, **kwargs) + + +def IfcReinforcingMesh(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMesh', 'IFC4', *args, **kwargs) + + +def IfcReinforcingMeshType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMeshType', 'IFC4', *args, **kwargs) + + +def IfcRelAggregates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAggregates', 'IFC4', *args, **kwargs) + + +def IfcRelAssigns(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssigns', 'IFC4', *args, **kwargs) + + +def IfcRelAssignsToActor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToActor', 'IFC4', *args, **kwargs) + + +def IfcRelAssignsToControl(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToControl', 'IFC4', *args, **kwargs) + + +def IfcRelAssignsToGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroup', 'IFC4', *args, **kwargs) + + +def IfcRelAssignsToGroupByFactor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroupByFactor', 'IFC4', *args, **kwargs) + + +def IfcRelAssignsToProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProcess', 'IFC4', *args, **kwargs) + + +def IfcRelAssignsToProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProduct', 'IFC4', *args, **kwargs) + + +def IfcRelAssignsToResource(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToResource', 'IFC4', *args, **kwargs) + + +def IfcRelAssociates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociates', 'IFC4', *args, **kwargs) + + +def IfcRelAssociatesApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesApproval', 'IFC4', *args, **kwargs) + + +def IfcRelAssociatesClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesClassification', 'IFC4', *args, **kwargs) + + +def IfcRelAssociatesConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesConstraint', 'IFC4', *args, **kwargs) + + +def IfcRelAssociatesDocument(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesDocument', 'IFC4', *args, **kwargs) + + +def IfcRelAssociatesLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesLibrary', 'IFC4', *args, **kwargs) + + +def IfcRelAssociatesMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesMaterial', 'IFC4', *args, **kwargs) + + +def IfcRelConnects(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnects', 'IFC4', *args, **kwargs) + + +def IfcRelConnectsElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsElements', 'IFC4', *args, **kwargs) + + +def IfcRelConnectsPathElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPathElements', 'IFC4', *args, **kwargs) + + +def IfcRelConnectsPortToElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPortToElement', 'IFC4', *args, **kwargs) + + +def IfcRelConnectsPorts(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPorts', 'IFC4', *args, **kwargs) + + +def IfcRelConnectsStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralActivity', 'IFC4', *args, **kwargs) + + +def IfcRelConnectsStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralMember', 'IFC4', *args, **kwargs) + + +def IfcRelConnectsWithEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithEccentricity', 'IFC4', *args, **kwargs) + + +def IfcRelConnectsWithRealizingElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithRealizingElements', 'IFC4', *args, **kwargs) + + +def IfcRelContainedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelContainedInSpatialStructure', 'IFC4', *args, **kwargs) + + +def IfcRelCoversBldgElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversBldgElements', 'IFC4', *args, **kwargs) + + +def IfcRelCoversSpaces(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversSpaces', 'IFC4', *args, **kwargs) + + +def IfcRelDeclares(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDeclares', 'IFC4', *args, **kwargs) + + +def IfcRelDecomposes(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDecomposes', 'IFC4', *args, **kwargs) + + +def IfcRelDefines(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefines', 'IFC4', *args, **kwargs) + + +def IfcRelDefinesByObject(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByObject', 'IFC4', *args, **kwargs) + + +def IfcRelDefinesByProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByProperties', 'IFC4', *args, **kwargs) + + +def IfcRelDefinesByTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByTemplate', 'IFC4', *args, **kwargs) + + +def IfcRelDefinesByType(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByType', 'IFC4', *args, **kwargs) + + +def IfcRelFillsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFillsElement', 'IFC4', *args, **kwargs) + + +def IfcRelFlowControlElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFlowControlElements', 'IFC4', *args, **kwargs) + + +def IfcRelInterferesElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelInterferesElements', 'IFC4', *args, **kwargs) + + +def IfcRelNests(*args, **kwargs): return ifcopenshell.create_entity('IfcRelNests', 'IFC4', *args, **kwargs) + + +def IfcRelProjectsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelProjectsElement', 'IFC4', *args, **kwargs) + + +def IfcRelReferencedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelReferencedInSpatialStructure', 'IFC4', *args, **kwargs) + + +def IfcRelSequence(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSequence', 'IFC4', *args, **kwargs) + + +def IfcRelServicesBuildings(*args, **kwargs): return ifcopenshell.create_entity('IfcRelServicesBuildings', 'IFC4', *args, **kwargs) + + +def IfcRelSpaceBoundary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary', 'IFC4', *args, **kwargs) + + +def IfcRelSpaceBoundary1stLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary1stLevel', 'IFC4', *args, **kwargs) + + +def IfcRelSpaceBoundary2ndLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary2ndLevel', 'IFC4', *args, **kwargs) + + +def IfcRelVoidsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelVoidsElement', 'IFC4', *args, **kwargs) + + +def IfcRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcRelationship', 'IFC4', *args, **kwargs) + + +def IfcReparametrisedCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcReparametrisedCompositeCurveSegment', 'IFC4', *args, **kwargs) + + +def IfcRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentation', 'IFC4', *args, **kwargs) + + +def IfcRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationContext', 'IFC4', *args, **kwargs) + + +def IfcRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationItem', 'IFC4', *args, **kwargs) + + +def IfcRepresentationMap(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationMap', 'IFC4', *args, **kwargs) + + +def IfcResource(*args, **kwargs): return ifcopenshell.create_entity('IfcResource', 'IFC4', *args, **kwargs) + + +def IfcResourceApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceApprovalRelationship', 'IFC4', *args, **kwargs) + + +def IfcResourceConstraintRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceConstraintRelationship', 'IFC4', *args, **kwargs) + + +def IfcResourceLevelRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceLevelRelationship', 'IFC4', *args, **kwargs) + + +def IfcResourceTime(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceTime', 'IFC4', *args, **kwargs) + + +def IfcRevolvedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolid', 'IFC4', *args, **kwargs) + + +def IfcRevolvedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolidTapered', 'IFC4', *args, **kwargs) + + +def IfcRightCircularCone(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCone', 'IFC4', *args, **kwargs) + + +def IfcRightCircularCylinder(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCylinder', 'IFC4', *args, **kwargs) + + +def IfcRoof(*args, **kwargs): return ifcopenshell.create_entity('IfcRoof', 'IFC4', *args, **kwargs) + + +def IfcRoofType(*args, **kwargs): return ifcopenshell.create_entity('IfcRoofType', 'IFC4', *args, **kwargs) + + +def IfcRoot(*args, **kwargs): return ifcopenshell.create_entity('IfcRoot', 'IFC4', *args, **kwargs) + + +def IfcRoundedRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRoundedRectangleProfileDef', 'IFC4', *args, **kwargs) + + +def IfcSIUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcSIUnit', 'IFC4', *args, **kwargs) + + +def IfcSanitaryTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminal', 'IFC4', *args, **kwargs) + + +def IfcSanitaryTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminalType', 'IFC4', *args, **kwargs) + + +def IfcSchedulingTime(*args, **kwargs): return ifcopenshell.create_entity('IfcSchedulingTime', 'IFC4', *args, **kwargs) + + +def IfcSeamCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSeamCurve', 'IFC4', *args, **kwargs) + + +def IfcSectionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionProperties', 'IFC4', *args, **kwargs) + + +def IfcSectionReinforcementProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionReinforcementProperties', 'IFC4', *args, **kwargs) + + +def IfcSectionedSpine(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSpine', 'IFC4', *args, **kwargs) + + +def IfcSensor(*args, **kwargs): return ifcopenshell.create_entity('IfcSensor', 'IFC4', *args, **kwargs) + + +def IfcSensorType(*args, **kwargs): return ifcopenshell.create_entity('IfcSensorType', 'IFC4', *args, **kwargs) + + +def IfcShadingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDevice', 'IFC4', *args, **kwargs) + + +def IfcShadingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDeviceType', 'IFC4', *args, **kwargs) + + +def IfcShapeAspect(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeAspect', 'IFC4', *args, **kwargs) + + +def IfcShapeModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeModel', 'IFC4', *args, **kwargs) + + +def IfcShapeRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeRepresentation', 'IFC4', *args, **kwargs) + + +def IfcShellBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShellBasedSurfaceModel', 'IFC4', *args, **kwargs) + + +def IfcSimpleProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcSimpleProperty', 'IFC4', *args, **kwargs) + + +def IfcSimplePropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcSimplePropertyTemplate', 'IFC4', *args, **kwargs) + + +def IfcSite(*args, **kwargs): return ifcopenshell.create_entity('IfcSite', 'IFC4', *args, **kwargs) + + +def IfcSlab(*args, **kwargs): return ifcopenshell.create_entity('IfcSlab', 'IFC4', *args, **kwargs) + + +def IfcSlabElementedCase(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabElementedCase', 'IFC4', *args, **kwargs) + + +def IfcSlabStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabStandardCase', 'IFC4', *args, **kwargs) + + +def IfcSlabType(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabType', 'IFC4', *args, **kwargs) + + +def IfcSlippageConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcSlippageConnectionCondition', 'IFC4', *args, **kwargs) + + +def IfcSolarDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDevice', 'IFC4', *args, **kwargs) + + +def IfcSolarDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDeviceType', 'IFC4', *args, **kwargs) + + +def IfcSolidModel(*args, **kwargs): return ifcopenshell.create_entity('IfcSolidModel', 'IFC4', *args, **kwargs) + + +def IfcSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcSpace', 'IFC4', *args, **kwargs) + + +def IfcSpaceHeater(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeater', 'IFC4', *args, **kwargs) + + +def IfcSpaceHeaterType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeaterType', 'IFC4', *args, **kwargs) + + +def IfcSpaceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceType', 'IFC4', *args, **kwargs) + + +def IfcSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElement', 'IFC4', *args, **kwargs) + + +def IfcSpatialElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElementType', 'IFC4', *args, **kwargs) + + +def IfcSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElement', 'IFC4', *args, **kwargs) + + +def IfcSpatialStructureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElementType', 'IFC4', *args, **kwargs) + + +def IfcSpatialZone(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZone', 'IFC4', *args, **kwargs) + + +def IfcSpatialZoneType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZoneType', 'IFC4', *args, **kwargs) + + +def IfcSphere(*args, **kwargs): return ifcopenshell.create_entity('IfcSphere', 'IFC4', *args, **kwargs) + + +def IfcSphericalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSphericalSurface', 'IFC4', *args, **kwargs) + + +def IfcStackTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminal', 'IFC4', *args, **kwargs) + + +def IfcStackTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminalType', 'IFC4', *args, **kwargs) + + +def IfcStair(*args, **kwargs): return ifcopenshell.create_entity('IfcStair', 'IFC4', *args, **kwargs) + + +def IfcStairFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlight', 'IFC4', *args, **kwargs) + + +def IfcStairFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlightType', 'IFC4', *args, **kwargs) + + +def IfcStairType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairType', 'IFC4', *args, **kwargs) + + +def IfcStructuralAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAction', 'IFC4', *args, **kwargs) + + +def IfcStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralActivity', 'IFC4', *args, **kwargs) + + +def IfcStructuralAnalysisModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAnalysisModel', 'IFC4', *args, **kwargs) + + +def IfcStructuralConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnection', 'IFC4', *args, **kwargs) + + +def IfcStructuralConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnectionCondition', 'IFC4', *args, **kwargs) + + +def IfcStructuralCurveAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveAction', 'IFC4', *args, **kwargs) + + +def IfcStructuralCurveConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveConnection', 'IFC4', *args, **kwargs) + + +def IfcStructuralCurveMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMember', 'IFC4', *args, **kwargs) + + +def IfcStructuralCurveMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMemberVarying', 'IFC4', *args, **kwargs) + + +def IfcStructuralCurveReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveReaction', 'IFC4', *args, **kwargs) + + +def IfcStructuralItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralItem', 'IFC4', *args, **kwargs) + + +def IfcStructuralLinearAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLinearAction', 'IFC4', *args, **kwargs) + + +def IfcStructuralLoad(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoad', 'IFC4', *args, **kwargs) + + +def IfcStructuralLoadCase(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadCase', 'IFC4', *args, **kwargs) + + +def IfcStructuralLoadConfiguration(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadConfiguration', 'IFC4', *args, **kwargs) + + +def IfcStructuralLoadGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadGroup', 'IFC4', *args, **kwargs) + + +def IfcStructuralLoadLinearForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadLinearForce', 'IFC4', *args, **kwargs) + + +def IfcStructuralLoadOrResult(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadOrResult', 'IFC4', *args, **kwargs) + + +def IfcStructuralLoadPlanarForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadPlanarForce', 'IFC4', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacement(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacement', 'IFC4', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacementDistortion(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacementDistortion', 'IFC4', *args, **kwargs) + + +def IfcStructuralLoadSingleForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForce', 'IFC4', *args, **kwargs) + + +def IfcStructuralLoadSingleForceWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForceWarping', 'IFC4', *args, **kwargs) + + +def IfcStructuralLoadStatic(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadStatic', 'IFC4', *args, **kwargs) + + +def IfcStructuralLoadTemperature(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadTemperature', 'IFC4', *args, **kwargs) + + +def IfcStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralMember', 'IFC4', *args, **kwargs) + + +def IfcStructuralPlanarAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPlanarAction', 'IFC4', *args, **kwargs) + + +def IfcStructuralPointAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointAction', 'IFC4', *args, **kwargs) + + +def IfcStructuralPointConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointConnection', 'IFC4', *args, **kwargs) + + +def IfcStructuralPointReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointReaction', 'IFC4', *args, **kwargs) + + +def IfcStructuralReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralReaction', 'IFC4', *args, **kwargs) + + +def IfcStructuralResultGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralResultGroup', 'IFC4', *args, **kwargs) + + +def IfcStructuralSurfaceAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceAction', 'IFC4', *args, **kwargs) + + +def IfcStructuralSurfaceConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceConnection', 'IFC4', *args, **kwargs) + + +def IfcStructuralSurfaceMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMember', 'IFC4', *args, **kwargs) + + +def IfcStructuralSurfaceMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMemberVarying', 'IFC4', *args, **kwargs) + + +def IfcStructuralSurfaceReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceReaction', 'IFC4', *args, **kwargs) + + +def IfcStyleModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStyleModel', 'IFC4', *args, **kwargs) + + +def IfcStyledItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledItem', 'IFC4', *args, **kwargs) + + +def IfcStyledRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledRepresentation', 'IFC4', *args, **kwargs) + + +def IfcSubContractResource(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResource', 'IFC4', *args, **kwargs) + + +def IfcSubContractResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResourceType', 'IFC4', *args, **kwargs) + + +def IfcSubedge(*args, **kwargs): return ifcopenshell.create_entity('IfcSubedge', 'IFC4', *args, **kwargs) + + +def IfcSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSurface', 'IFC4', *args, **kwargs) + + +def IfcSurfaceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurve', 'IFC4', *args, **kwargs) + + +def IfcSurfaceCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurveSweptAreaSolid', 'IFC4', *args, **kwargs) + + +def IfcSurfaceFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceFeature', 'IFC4', *args, **kwargs) + + +def IfcSurfaceOfLinearExtrusion(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfLinearExtrusion', 'IFC4', *args, **kwargs) + + +def IfcSurfaceOfRevolution(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfRevolution', 'IFC4', *args, **kwargs) + + +def IfcSurfaceReinforcementArea(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceReinforcementArea', 'IFC4', *args, **kwargs) + + +def IfcSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyle', 'IFC4', *args, **kwargs) + + +def IfcSurfaceStyleLighting(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleLighting', 'IFC4', *args, **kwargs) + + +def IfcSurfaceStyleRefraction(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRefraction', 'IFC4', *args, **kwargs) + + +def IfcSurfaceStyleRendering(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRendering', 'IFC4', *args, **kwargs) + + +def IfcSurfaceStyleShading(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleShading', 'IFC4', *args, **kwargs) + + +def IfcSurfaceStyleWithTextures(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleWithTextures', 'IFC4', *args, **kwargs) + + +def IfcSurfaceTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceTexture', 'IFC4', *args, **kwargs) + + +def IfcSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptAreaSolid', 'IFC4', *args, **kwargs) + + +def IfcSweptDiskSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolid', 'IFC4', *args, **kwargs) + + +def IfcSweptDiskSolidPolygonal(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolidPolygonal', 'IFC4', *args, **kwargs) + + +def IfcSweptSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptSurface', 'IFC4', *args, **kwargs) + + +def IfcSwitchingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDevice', 'IFC4', *args, **kwargs) + + +def IfcSwitchingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDeviceType', 'IFC4', *args, **kwargs) + + +def IfcSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcSystem', 'IFC4', *args, **kwargs) + + +def IfcSystemFurnitureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElement', 'IFC4', *args, **kwargs) + + +def IfcSystemFurnitureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElementType', 'IFC4', *args, **kwargs) + + +def IfcTShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTShapeProfileDef', 'IFC4', *args, **kwargs) + + +def IfcTable(*args, **kwargs): return ifcopenshell.create_entity('IfcTable', 'IFC4', *args, **kwargs) + + +def IfcTableColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcTableColumn', 'IFC4', *args, **kwargs) + + +def IfcTableRow(*args, **kwargs): return ifcopenshell.create_entity('IfcTableRow', 'IFC4', *args, **kwargs) + + +def IfcTank(*args, **kwargs): return ifcopenshell.create_entity('IfcTank', 'IFC4', *args, **kwargs) + + +def IfcTankType(*args, **kwargs): return ifcopenshell.create_entity('IfcTankType', 'IFC4', *args, **kwargs) + + +def IfcTask(*args, **kwargs): return ifcopenshell.create_entity('IfcTask', 'IFC4', *args, **kwargs) + + +def IfcTaskTime(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTime', 'IFC4', *args, **kwargs) + + +def IfcTaskTimeRecurring(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTimeRecurring', 'IFC4', *args, **kwargs) + + +def IfcTaskType(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskType', 'IFC4', *args, **kwargs) + + +def IfcTelecomAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcTelecomAddress', 'IFC4', *args, **kwargs) + + +def IfcTendon(*args, **kwargs): return ifcopenshell.create_entity('IfcTendon', 'IFC4', *args, **kwargs) + + +def IfcTendonAnchor(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchor', 'IFC4', *args, **kwargs) + + +def IfcTendonAnchorType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchorType', 'IFC4', *args, **kwargs) + + +def IfcTendonType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonType', 'IFC4', *args, **kwargs) + + +def IfcTessellatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedFaceSet', 'IFC4', *args, **kwargs) + + +def IfcTessellatedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedItem', 'IFC4', *args, **kwargs) + + +def IfcTextLiteral(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteral', 'IFC4', *args, **kwargs) + + +def IfcTextLiteralWithExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteralWithExtent', 'IFC4', *args, **kwargs) + + +def IfcTextStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyle', 'IFC4', *args, **kwargs) + + +def IfcTextStyleFontModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleFontModel', 'IFC4', *args, **kwargs) + + +def IfcTextStyleForDefinedFont(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleForDefinedFont', 'IFC4', *args, **kwargs) + + +def IfcTextStyleTextModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleTextModel', 'IFC4', *args, **kwargs) + + +def IfcTextureCoordinate(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinate', 'IFC4', *args, **kwargs) + + +def IfcTextureCoordinateGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateGenerator', 'IFC4', *args, **kwargs) + + +def IfcTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureMap', 'IFC4', *args, **kwargs) + + +def IfcTextureVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertex', 'IFC4', *args, **kwargs) + + +def IfcTextureVertexList(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertexList', 'IFC4', *args, **kwargs) + + +def IfcTimePeriod(*args, **kwargs): return ifcopenshell.create_entity('IfcTimePeriod', 'IFC4', *args, **kwargs) + + +def IfcTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeries', 'IFC4', *args, **kwargs) + + +def IfcTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeriesValue', 'IFC4', *args, **kwargs) + + +def IfcTopologicalRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologicalRepresentationItem', 'IFC4', *args, **kwargs) + + +def IfcTopologyRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologyRepresentation', 'IFC4', *args, **kwargs) + + +def IfcToroidalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcToroidalSurface', 'IFC4', *args, **kwargs) + + +def IfcTransformer(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformer', 'IFC4', *args, **kwargs) + + +def IfcTransformerType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformerType', 'IFC4', *args, **kwargs) + + +def IfcTransportElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElement', 'IFC4', *args, **kwargs) + + +def IfcTransportElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElementType', 'IFC4', *args, **kwargs) + + +def IfcTrapeziumProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTrapeziumProfileDef', 'IFC4', *args, **kwargs) + + +def IfcTriangulatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedFaceSet', 'IFC4', *args, **kwargs) + + +def IfcTrimmedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcTrimmedCurve', 'IFC4', *args, **kwargs) + + +def IfcTubeBundle(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundle', 'IFC4', *args, **kwargs) + + +def IfcTubeBundleType(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundleType', 'IFC4', *args, **kwargs) + + +def IfcTypeObject(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeObject', 'IFC4', *args, **kwargs) + + +def IfcTypeProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProcess', 'IFC4', *args, **kwargs) + + +def IfcTypeProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProduct', 'IFC4', *args, **kwargs) + + +def IfcTypeResource(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeResource', 'IFC4', *args, **kwargs) + + +def IfcUShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcUShapeProfileDef', 'IFC4', *args, **kwargs) + + +def IfcUnitAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitAssignment', 'IFC4', *args, **kwargs) + + +def IfcUnitaryControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElement', 'IFC4', *args, **kwargs) + + +def IfcUnitaryControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElementType', 'IFC4', *args, **kwargs) + + +def IfcUnitaryEquipment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipment', 'IFC4', *args, **kwargs) + + +def IfcUnitaryEquipmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipmentType', 'IFC4', *args, **kwargs) + + +def IfcValve(*args, **kwargs): return ifcopenshell.create_entity('IfcValve', 'IFC4', *args, **kwargs) + + +def IfcValveType(*args, **kwargs): return ifcopenshell.create_entity('IfcValveType', 'IFC4', *args, **kwargs) + + +def IfcVector(*args, **kwargs): return ifcopenshell.create_entity('IfcVector', 'IFC4', *args, **kwargs) + + +def IfcVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcVertex', 'IFC4', *args, **kwargs) + + +def IfcVertexLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexLoop', 'IFC4', *args, **kwargs) + + +def IfcVertexPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexPoint', 'IFC4', *args, **kwargs) + + +def IfcVibrationIsolator(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolator', 'IFC4', *args, **kwargs) + + +def IfcVibrationIsolatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolatorType', 'IFC4', *args, **kwargs) + + +def IfcVirtualElement(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualElement', 'IFC4', *args, **kwargs) + + +def IfcVirtualGridIntersection(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualGridIntersection', 'IFC4', *args, **kwargs) + + +def IfcVoidingFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcVoidingFeature', 'IFC4', *args, **kwargs) + + +def IfcWall(*args, **kwargs): return ifcopenshell.create_entity('IfcWall', 'IFC4', *args, **kwargs) + + +def IfcWallElementedCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallElementedCase', 'IFC4', *args, **kwargs) + + +def IfcWallStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallStandardCase', 'IFC4', *args, **kwargs) + + +def IfcWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcWallType', 'IFC4', *args, **kwargs) + + +def IfcWasteTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminal', 'IFC4', *args, **kwargs) + + +def IfcWasteTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminalType', 'IFC4', *args, **kwargs) + + +def IfcWindow(*args, **kwargs): return ifcopenshell.create_entity('IfcWindow', 'IFC4', *args, **kwargs) + + +def IfcWindowLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowLiningProperties', 'IFC4', *args, **kwargs) + + +def IfcWindowPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowPanelProperties', 'IFC4', *args, **kwargs) + + +def IfcWindowStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowStandardCase', 'IFC4', *args, **kwargs) + + +def IfcWindowStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowStyle', 'IFC4', *args, **kwargs) + + +def IfcWindowType(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowType', 'IFC4', *args, **kwargs) + + +def IfcWorkCalendar(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkCalendar', 'IFC4', *args, **kwargs) + + +def IfcWorkControl(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkControl', 'IFC4', *args, **kwargs) + + +def IfcWorkPlan(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkPlan', 'IFC4', *args, **kwargs) + + +def IfcWorkSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkSchedule', 'IFC4', *args, **kwargs) + + +def IfcWorkTime(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkTime', 'IFC4', *args, **kwargs) + + +def IfcZShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcZShapeProfileDef', 'IFC4', *args, **kwargs) + + +def IfcZone(*args, **kwargs): return ifcopenshell.create_entity('IfcZone', 'IFC4', *args, **kwargs) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcBoxAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcBoxAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['top-left','top-middle','top-right','middle-left','center','middle-right','bottom-left','bottom-middle','bottom-right'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCardinalPointReference_GreaterThanZero: + SCOPE = "type" + TYPE_NAME = "IfcCardinalPointReference" + RULE_NAME = "GreaterThanZero" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCompoundPlaneAngleMeasure_MinutesInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MinutesInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[2 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_SecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "SecondsInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[3 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_MicrosecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MicrosecondsInRange" + + @staticmethod + def __call__(self): + + + assert (sizeof(self) == 3) or ((abs(self[4 - 1])) < 1000000) + + + + +class IfcCompoundPlaneAngleMeasure_ConsistentSign: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "ConsistentSign" + + @staticmethod + def __call__(self): + + + assert (((self[1 - 1]) >= 0) and ((self[2 - 1]) >= 0) and ((self[3 - 1]) >= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) >= 0))) or (((self[1 - 1]) <= 0) and ((self[2 - 1]) <= 0) and ((self[3 - 1]) <= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) <= 0))) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDayInMonthNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInMonthNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 31 + + + + + +class IfcDayInWeekNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInWeekNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 7 + + + + + + + + + + + + + + + + + +class IfcDimensionCount_WR1: + SCOPE = "type" + TYPE_NAME = "IfcDimensionCount" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0 < self <= 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFontStyle_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontStyle" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','italic','oblique'] + + + + + +class IfcFontVariant_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontVariant" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps'] + + + + + +class IfcFontWeight_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontWeight" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps','100','200','300','400','500','600','700','800','900'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcHeatingValueMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcHeatingValueMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMonthInYearNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcMonthInYearNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 12 + + + + + + + + +class IfcNonNegativeLengthMeasure_NotNegative: + SCOPE = "type" + TYPE_NAME = "IfcNonNegativeLengthMeasure" + RULE_NAME = "NotNegative" + + @staticmethod + def __call__(self): + + + assert self >= 0. + + + + + +class IfcNormalisedRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcNormalisedRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPHMeasure_WR21: + SCOPE = "type" + TYPE_NAME = "IfcPHMeasure" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 14.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPositiveInteger_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveInteger" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + +class IfcPositiveLengthMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveLengthMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositivePlaneAngleMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositivePlaneAngleMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositiveRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcSpecularRoughness_WR1: + SCOPE = "type" + TYPE_NAME = "IfcSpecularRoughness" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTextAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['left','right','center','justify'] + + + + + +class IfcTextDecoration_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextDecoration" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['none','underline','overline','line-through','blink'] + + + + + + + + + + + + + + +class IfcTextTransformation_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextTransformation" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['capitalize','uppercase','lowercase','none'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcActorRole_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcActorRole" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + role = self.Role + + assert (role != IfcRoleEnum.USERDEFINED) or ((role == IfcRoleEnum.USERDEFINED) and exists(self.UserDefinedRole)) + + + + + +class IfcActuator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcActuator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcactuatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcActuatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + purpose = self.Purpose + + assert (not exists(purpose)) or ((purpose != IfcAddressTypeEnum.USERDEFINED) or ((purpose == IfcAddressTypeEnum.USERDEFINED) and exists(self.UserDefinedPurpose))) + + + + + +class IfcAdvancedBrep_HasAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrep" + RULE_NAME = "HasAdvancedFaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([afs for afs in self.Outer.CfsFaces if not 'ifc4.ifcadvancedface' in typeof(afs)])) == 0 + + + + + +class IfcAdvancedBrepWithVoids_VoidsHaveAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrepWithVoids" + RULE_NAME = "VoidsHaveAdvancedFaces" + + @staticmethod + def __call__(self): + voids = self.Voids + + assert (sizeof([vsh for vsh in voids if (sizeof([afs for afs in vsh.CfsFaces if not 'ifc4.ifcadvancedface' in typeof(afs)])) == 0])) == 0 + + + + + +class IfcAdvancedFace_ApplicableSurface: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableSurface" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4.ifcelementarysurface','ifc4.ifcsweptsurface','ifc4.ifcbsplinesurface'] * typeof(self.FaceSurface))) == 1 + + + + +class IfcAdvancedFace_RequiresEdgeCurve: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "RequiresEdgeCurve" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not 'ifc4.ifcedgecurve' in typeof(oe.EdgeElement)])) == 0])) == 0 + + + + +class IfcAdvancedFace_ApplicableEdgeCurves: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableEdgeCurves" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not (sizeof(['ifc4.ifcline','ifc4.ifcconic','ifc4.ifcpolyline','ifc4.ifcbsplinecurve'] * typeof(oe.EdgeElement.EdgeGeometry))) == 1])) == 0])) == 0 + + + + + +class IfcAirTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcairterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminalBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcairterminalboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirToAirHeatRecovery_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirToAirHeatRecovery_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcairtoairheatrecoverytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirToAirHeatRecoveryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecoveryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAlarm_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAlarm_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcalarmtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAlarmType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarmType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + +class IfcApproval_HasIdentifierOrName: + SCOPE = "entity" + TYPE_NAME = "IfcApproval" + RULE_NAME = "HasIdentifierOrName" + + @staticmethod + def __call__(self): + identifier = self.Identifier + name = self.Name + + assert exists(identifier) or exists(name) + + + + + + + + +class IfcArbitraryClosedProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert outercurve.Dim == 2 + + + + +class IfcArbitraryClosedProfileDef_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4.ifcline' in typeof(outercurve) + + + + +class IfcArbitraryClosedProfileDef_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4.ifcoffsetcurve2d' in typeof(outercurve) + + + + + +class IfcArbitraryOpenProfileDef_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert ('ifc4.ifccenterlineprofiledef' in typeof(self)) or (self.ProfileType == IfcProfileTypeEnum.CURVE) + + + + +class IfcArbitraryOpenProfileDef_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + curve = self.Curve + + assert curve.Dim == 2 + + + + + +class IfcArbitraryProfileDefWithVoids_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == area + + + + +class IfcArbitraryProfileDefWithVoids_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if temp.Dim != 2])) == 0 + + + + +class IfcArbitraryProfileDefWithVoids_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if 'ifc4.ifcline' in typeof(temp)])) == 0 + + + + + + + + +class IfcAsymmetricIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + bottomflangethickness = self.BottomFlangeThickness + topflangethickness = self.TopFlangeThickness + + assert (not exists(topflangethickness)) or ((bottomflangethickness + topflangethickness) < overalldepth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + + assert (webthickness < bottomflangewidth) and (webthickness < topflangewidth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidBottomFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidBottomFilletRadius" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + bottomflangefilletradius = self.BottomFlangeFilletRadius + + assert (not exists(bottomflangefilletradius)) or (bottomflangefilletradius <= ((bottomflangewidth - webthickness) / 2.)) + + + + +class IfcAsymmetricIShapeProfileDef_ValidTopFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidTopFilletRadius" + + @staticmethod + def __call__(self): + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + topflangefilletradius = self.TopFlangeFilletRadius + + assert (not exists(topflangefilletradius)) or (topflangefilletradius <= ((topflangewidth - webthickness) / 2.)) + + + + + +class IfcAudioVisualAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAudioVisualAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcaudiovisualappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAudioVisualApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAxis1Placement_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis1Placement_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +def calc_IfcAxis1Placement_Z(self): + axis = self.Axis + return \ + nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + + + + +class IfcAxis2Placement2D_RefDirIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "RefDirIs2D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 2) + + + + +class IfcAxis2Placement2D_LocationIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIs2D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 2 + + + + +def calc_IfcAxis2Placement2D_P(self): + refdirection = self.RefDirection + return \ + IfcBuild2Axes(refdirection) + + + + +class IfcAxis2Placement3D_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis2Placement3D_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis2Placement3D_RefDirIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "RefDirIs3D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 3) + + + + +class IfcAxis2Placement3D_AxisToRefDirPosition: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisToRefDirPosition" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + +class IfcAxis2Placement3D_AxisAndRefDirProvision: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisAndRefDirProvision" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert not exists(axis) ^ exists(refdirection) + + + + +def calc_IfcAxis2Placement3D_P(self): + axis = self.Axis + refdirection = self.RefDirection + return \ + IfcBuildAxes(axis,refdirection) + + + + +class IfcBSplineCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + controlpointslist = self.ControlPointsList + + assert (sizeof([temp for temp in controlpointslist if temp.Dim != (controlpointslist[1 - 1].Dim)])) == 0 + + + + +def calc_IfcBSplineCurve_UpperIndexOnControlPoints(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineCurve_ControlPoints(self): + controlpointslist = self.ControlPointsList + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + return \ + IfcListToArray(controlpointslist,0,upperindexoncontrolpoints) + + + + +class IfcBSplineCurveWithKnots_ConsistentBSpline: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "ConsistentBSpline" + + @staticmethod + def __call__(self): + degree = self.Degree + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + knotmultiplicities = self.KnotMultiplicities + knots = self.Knots + upperindexonknots = self.UpperIndexOnKnots + + assert IfcConstraintsParamBSpline(degree,upperindexonknots,upperindexoncontrolpoints,knotmultiplicities,knots) + + + + +class IfcBSplineCurveWithKnots_CorrespondingKnotLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "CorrespondingKnotLists" + + @staticmethod + def __call__(self): + knotmultiplicities = self.KnotMultiplicities + upperindexonknots = self.UpperIndexOnKnots + + assert sizeof(knotmultiplicities) == upperindexonknots + + + + +def calc_IfcBSplineCurveWithKnots_UpperIndexOnKnots(self): + knots = self.Knots + return \ + sizeof(knots) + + + + +def calc_IfcBSplineSurface_UUpper(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineSurface_VUpper(self): + controlpointslist = self.ControlPointsList + return \ + (sizeof(controlpointslist[1 - 1])) - 1 + + + +def calc_IfcBSplineSurface_ControlPoints(self): + controlpointslist = self.ControlPointsList + uupper = self.UUpper + vupper = self.VUpper + return \ + IfcMakeArrayOfArray(controlpointslist,0,uupper,0,vupper) + + + + +class IfcBSplineSurfaceWithKnots_UDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "UDirectionConstraints" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + uknots = self.UKnots + knotuupper = self.KnotUUpper + + assert IfcConstraintsParamBSpline(self.UDegree,knotuupper,self.UUpper,umultiplicities,uknots) + + + + +class IfcBSplineSurfaceWithKnots_VDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "VDirectionConstraints" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + vknots = self.VKnots + knotvupper = self.KnotVUpper + + assert IfcConstraintsParamBSpline(self.VDegree,knotvupper,self.VUpper,vmultiplicities,vknots) + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingULists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingULists" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + knotuupper = self.KnotUUpper + + assert sizeof(umultiplicities) == knotuupper + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingVLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingVLists" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + knotvupper = self.KnotVUpper + + assert sizeof(vmultiplicities) == knotvupper + + + + +def calc_IfcBSplineSurfaceWithKnots_KnotVUpper(self): + vknots = self.VKnots + return \ + sizeof(vknots) + + + +def calc_IfcBSplineSurfaceWithKnots_KnotUUpper(self): + uknots = self.UKnots + return \ + sizeof(uknots) + + + + +class IfcBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBeamStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcBeamStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4.ifcrelassociates.relatedobjects') if ('ifc4.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBlobTexture_SupportedRasterFormat: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "SupportedRasterFormat" + + @staticmethod + def __call__(self): + + + assert self.RasterFormat in ['bmp','jpg','gif','png'] + + + + +class IfcBlobTexture_RasterCodeByteStream: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "RasterCodeByteStream" + + @staticmethod + def __call__(self): + rastercode = self.RasterCode + + assert (blength(rastercode) % 8) == 0 + + + + + + + + +class IfcBoiler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBoiler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcboilertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBoilerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoilerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBooleanClippingResult_FirstOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "FirstOperandType" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert ('ifc4.ifcsweptareasolid' in typeof(firstoperand)) or ('ifc4.ifcsweptdiscsolid' in typeof(firstoperand)) or ('ifc4.ifcbooleanclippingresult' in typeof(firstoperand)) + + + + +class IfcBooleanClippingResult_SecondOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "SecondOperandType" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert 'ifc4.ifchalfspacesolid' in typeof(secondoperand) + + + + +class IfcBooleanClippingResult_OperatorType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "OperatorType" + + @staticmethod + def __call__(self): + operator = self.Operator + + assert operator == difference + + + + + +class IfcBooleanResult_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + secondoperand = self.SecondOperand + + assert firstoperand.Dim == secondoperand.Dim + + + + +class IfcBooleanResult_FirstOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "FirstOperandClosed" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert (not 'ifc4.ifctessellatedfaceset' in typeof(firstoperand)) or (exists(firstoperand.Closed) and firstoperand.Closed) + + + + +class IfcBooleanResult_SecondOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SecondOperandClosed" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert (not 'ifc4.ifctessellatedfaceset' in typeof(secondoperand)) or (exists(secondoperand.Closed) and secondoperand.Closed) + + + + +def calc_IfcBooleanResult_Dim(self): + firstoperand = self.FirstOperand + return \ + firstoperand.Dim + + + + + + + +class IfcBoundaryCurve_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBoundaryCurve" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + + + assert self.ClosedCurve + + + + + + + + + + + + + + + + + + + + + + + +def calc_IfcBoundingBox_Dim(self): + + return \ + 3 + + + + +class IfcBoxedHalfSpace_UnboundedSurface: + SCOPE = "entity" + TYPE_NAME = "IfcBoxedHalfSpace" + RULE_NAME = "UnboundedSurface" + + @staticmethod + def __call__(self): + + + assert not 'ifc4.ifccurveboundedplane' in typeof(self.BaseSurface) + + + + + + + + +class IfcBuildingElement_MaxOneMaterialAssociation: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElement" + RULE_NAME = "MaxOneMaterialAssociation" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.HasAssociations if 'ifc4.ifcrelassociatesmaterial' in typeof(temp)])) <= 1 + + + + + +class IfcBuildingElementPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementPart_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcbuildingelementparttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementPartType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPartType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBuildingElementProxy_HasObjectName: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "HasObjectName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcBuildingElementProxy_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementProxy_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcbuildingelementproxytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementProxyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcBurner_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBurner_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcburnertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBurnerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurnerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCShapeProfileDef_ValidGirth: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidGirth" + + @staticmethod + def __call__(self): + depth = self.Depth + girth = self.Girth + + assert girth < (depth / 2.) + + + + +class IfcCShapeProfileDef_ValidInternalFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidInternalFilletRadius" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + internalfilletradius = self.InternalFilletRadius + + assert (not exists(internalfilletradius)) or ((internalfilletradius <= ((width / 2.) - wallthickness)) and (internalfilletradius <= ((depth / 2.) - wallthickness))) + + + + +class IfcCShapeProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + + assert (wallthickness < (width / 2.)) and (wallthickness < (depth / 2.)) + + + + + +class IfcCableCarrierFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifccablecarrierfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableCarrierSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifccablecarriersegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifccablefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifccablesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCartesianPoint_CP2Dor3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianPoint" + RULE_NAME = "CP2Dor3D" + + @staticmethod + def __call__(self): + coordinates = self.Coordinates + + assert hiindex(coordinates) >= 2 + + + + +def calc_IfcCartesianPoint_Dim(self): + coordinates = self.Coordinates + return \ + hiindex(coordinates) + + + + +def calc_IfcCartesianPointList_Dim(self): + + return \ + IfcPointListDim(self) + + + + + + + + + + +class IfcCartesianTransformationOperator_ScaleGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator" + RULE_NAME = "ScaleGreaterZero" + + @staticmethod + def __call__(self): + scl = self.Scl + + assert scl > 0.0 + + + + +def calc_IfcCartesianTransformationOperator_Scl(self): + scale = self.Scale + return \ + nvl(scale,1.0) + + + +def calc_IfcCartesianTransformationOperator_Dim(self): + localorigin = self.LocalOrigin + return \ + localorigin.Dim + + + + +class IfcCartesianTransformationOperator2D_DimEqual2: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "DimEqual2" + + @staticmethod + def __call__(self): + + + assert self.Dim == 2 + + + + +class IfcCartesianTransformationOperator2D_Axis1Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis1Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 2) + + + + +class IfcCartesianTransformationOperator2D_Axis2Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis2Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 2) + + + + +def calc_IfcCartesianTransformationOperator2D_U(self): + + return \ + IfcBaseAxis(2,self.Axis1,self.Axis2,None) + + + + +class IfcCartesianTransformationOperator2DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator2DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + + +class IfcCartesianTransformationOperator3D_DimIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "DimIs3D" + + @staticmethod + def __call__(self): + + + assert self.Dim == 3 + + + + +class IfcCartesianTransformationOperator3D_Axis1Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis1Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis2Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis2Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis3Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis3Is3D" + + @staticmethod + def __call__(self): + axis3 = self.Axis3 + + assert (not exists(axis3)) or (axis3.Dim == 3) + + + + +def calc_IfcCartesianTransformationOperator3D_U(self): + axis3 = self.Axis3 + return \ + IfcBaseAxis(3,self.Axis1,self.Axis2,axis3) + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale3GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale3GreaterZero" + + @staticmethod + def __call__(self): + scl3 = self.Scl3 + + assert scl3 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl3(self): + scale3 = self.Scale3 + return \ + nvl(scale3,self.Scl) + + + + + + + +class IfcChiller_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChiller_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcchillertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChillerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChillerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcChimney_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChimney_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcchimneytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChimneyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimneyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcCircleHollowProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCircleHollowProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert wallthickness < self.Radius + + + + + + + + + + + + + + + + + + + + + + + +class IfcCoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoil_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifccoiltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoilType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoilType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcColumn_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcColumn_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifccolumntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcColumnStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcColumnStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4.ifcrelassociates.relatedobjects') if ('ifc4.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcColumnType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumnType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifccommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcComplexProperty_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert (sizeof([temp for temp in hasproperties if self == temp])) == 0 + + + + +class IfcComplexProperty_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + +class IfcComplexPropertyTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + +class IfcComplexPropertyTemplate_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert (sizeof([temp for temp in haspropertytemplates if self == temp])) == 0 + + + + + +class IfcCompositeCurve_CurveContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "CurveContinuous" + + @staticmethod + def __call__(self): + segments = self.Segments + closedcurve = self.ClosedCurve + + assert ((not closedcurve) and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 1)) or (closedcurve and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 0)) + + + + +class IfcCompositeCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (sizeof([temp for temp in segments if temp.Dim != (segments[1 - 1].Dim)])) == 0 + + + + +def calc_IfcCompositeCurve_NSegments(self): + segments = self.Segments + return \ + sizeof(segments) + + + +def calc_IfcCompositeCurve_ClosedCurve(self): + segments = self.Segments + nsegments = self.NSegments + return \ + (segments[nsegments - 1].Transition) != discontinuous + + + + +class IfcCompositeCurveOnSurface_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveOnSurface" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + + assert sizeof(basissurface) > 0 + + + + +def calc_IfcCompositeCurveOnSurface_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + +class IfcCompositeCurveSegment_ParentIsBoundedCurve: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveSegment" + RULE_NAME = "ParentIsBoundedCurve" + + @staticmethod + def __call__(self): + parentcurve = self.ParentCurve + + assert 'ifc4.ifcboundedcurve' in typeof(parentcurve) + + + + +def calc_IfcCompositeCurveSegment_Dim(self): + parentcurve = self.ParentCurve + return \ + parentcurve.Dim + + + + +class IfcCompositeProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if temp.ProfileType != (profiles[1 - 1].ProfileType)])) == 0 + + + + +class IfcCompositeProfileDef_NoRecursion: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "NoRecursion" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if 'ifc4.ifccompositeprofiledef' in typeof(temp)])) == 0 + + + + + +class IfcCompressor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCompressor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifccompressortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCompressorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCondenser_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCondenser_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifccondensertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCondenserType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenserType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcConstraint_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcConstraint" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + constraintgrade = self.ConstraintGrade + + assert (constraintgrade != IfcConstraintEnum.USERDEFINED) or ((constraintgrade == IfcConstraintEnum.USERDEFINED) and exists(self.UserDefinedGrade)) + + + + + +class IfcConstructionEquipmentResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionEquipmentResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionMaterialResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionMaterialResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionProductResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionProductResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + + + + + + + + + + + + + +class IfcController_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcController_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifccontrollertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcControllerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcControllerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcCooledBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCooledBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifccooledbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCooledBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCoolingTower_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoolingTower_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifccoolingtowertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoolingTowerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTowerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + +class IfcCovering_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCovering_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifccoveringtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoveringType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoveringType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCrewResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcCrewResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +def calc_IfcCsgPrimitive3D_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcCurtainWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCurtainWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifccurtainwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCurtainWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcCurve_Dim(self): + + return \ + IfcCurveDim(self) + + + + + + + + + + +class IfcCurveStyle_MeasureOfWidth: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "MeasureOfWidth" + + @staticmethod + def __call__(self): + curvewidth = self.CurveWidth + + assert (not exists(curvewidth)) or ('ifc4.ifcpositivelengthmeasure' in typeof(curvewidth)) or (('ifc4.ifcdescriptivemeasure' in typeof(curvewidth)) and (curvewidth == 'bylayer')) + + + + +class IfcCurveStyle_IdentifiableCurveStyle: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "IdentifiableCurveStyle" + + @staticmethod + def __call__(self): + curvefont = self.CurveFont + curvewidth = self.CurveWidth + curvecolour = self.CurveColour + + assert exists(curvefont) or exists(curvewidth) or exists(curvecolour) + + + + + + + + + + + +class IfcCurveStyleFontPattern_VisibleLengthGreaterEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyleFontPattern" + RULE_NAME = "VisibleLengthGreaterEqualZero" + + @staticmethod + def __call__(self): + visiblesegmentlength = self.VisibleSegmentLength + + assert visiblesegmentlength >= 0. + + + + + + + + +class IfcDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDerivedProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + parentprofile = self.ParentProfile + + assert self.ProfileType == parentprofile.ProfileType + + + + + +class IfcDerivedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof(elements) > 1) or ((sizeof(elements) == 1) and ((elements[1 - 1].Exponent) != 1)) + + + + +class IfcDerivedUnit_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + unittype = self.UnitType + + assert (unittype != IfcDerivedUnitEnum.USERDEFINED) or ((unittype == IfcDerivedUnitEnum.USERDEFINED) and exists(self.UserDefinedType)) + + + + +def calc_IfcDerivedUnit_Dimensions(self): + elements = self.Elements + return \ + IfcDeriveDimensionalExponents(elements) + + + + + + + + + + +class IfcDirection_MagnitudeGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcDirection" + RULE_NAME = "MagnitudeGreaterZero" + + @staticmethod + def __call__(self): + directionratios = self.DirectionRatios + + assert (sizeof([tmp for tmp in directionratios if tmp != 0.0])) > 0 + + + + +def calc_IfcDirection_Dim(self): + directionratios = self.DirectionRatios + return \ + hiindex(directionratios) + + + + +class IfcDiscreteAccessory_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDiscreteAccessory_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcdiscreteaccessorytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDiscreteAccessoryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessoryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDistributionChamberElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionChamberElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcdistributionchamberelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionChamberElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDocumentReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDocumentReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + name = self.Name + referenceddocument = self.ReferencedDocument + + assert exists(name) ^ exists(referenceddocument) + + + + + +class IfcDoor_CorrectStyleAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectStyleAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcdoortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDoorLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcDoorLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + thresholddepth = self.ThresholdDepth + thresholdthickness = self.ThresholdThickness + + assert not exists(thresholddepth) and (not exists(thresholdthickness)) + + + + +class IfcDoorLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + transomthickness = self.TransomThickness + transomoffset = self.TransomOffset + + assert (exists(transomoffset) and exists(transomthickness)) ^ ((not exists(transomoffset)) and (not exists(transomthickness))) + + + + +class IfcDoorLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + casingthickness = self.CasingThickness + casingdepth = self.CasingDepth + + assert (exists(casingdepth) and exists(casingthickness)) ^ ((not exists(casingdepth)) and (not exists(casingthickness))) + + + + +class IfcDoorLiningProperties_WR35: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR35" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcDoorPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + + + + + + + +class IfcDoorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDoorTypeEnum.USERDEFINED) or ((predefinedtype == IfcDoorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDraughtingPreDefinedColour_PreDefinedColourNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedColour" + RULE_NAME = "PreDefinedColourNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['black','red','green','blue','yellow','magenta','cyan','white','bylayer'] + + + + + +class IfcDraughtingPreDefinedCurveFont_PreDefinedCurveFontNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedCurveFont" + RULE_NAME = "PreDefinedCurveFontNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['continuous','chain','chaindoubledash','dashed','dotted','bylayer'] + + + + + +class IfcDuctFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcductfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcductsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSilencer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSilencer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcductsilencertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSilencerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcEdgeLoop_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + edgelist = self.EdgeList + ne = self.Ne + + assert (edgelist[1 - 1].EdgeStart) == (edgelist[ne - 1].EdgeEnd) + + + + +class IfcEdgeLoop_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcLoopHeadToTail(self) + + + + +def calc_IfcEdgeLoop_Ne(self): + edgelist = self.EdgeList + return \ + sizeof(edgelist) + + + + +class IfcElectricAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcelectricappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcelectricdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowStorageDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowStorageDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcelectricflowstoragedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowStorageDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricGenerator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricGenerator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcelectricgeneratortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricGeneratorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGeneratorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricMotor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricMotor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcelectricmotortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricMotorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricTimeControl_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricTimeControl_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcelectrictimecontroltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricTimeControlType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControlType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcElementAssembly_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElementAssembly_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcelementassemblytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElementAssemblyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssemblyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcElementQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcElementQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + quantities = self.Quantities + + assert IfcUniqueQuantityNames(quantities) + + + + + + + + + + + + + + + + + + + + + + + +class IfcEngine_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEngine_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcenginetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEngineType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngineType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporativeCooler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporativeCooler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcevaporativecoolertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporativeCoolerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCoolerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcevaporatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvent_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvent_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (not exists(eventtriggertype)) or (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + +class IfcEventType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + +class IfcEventType_CorrectEventTriggerType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectEventTriggerType" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + + + + +class IfcExternalReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcExternalReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + location = self.Location + identification = self.Identification + name = self.Name + + assert exists(identification) or exists(location) or exists(name) + + + + + + + + + + + + + + + + + + + + + + + +class IfcExtrudedAreaSolid_ValidExtrusionDirection: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolid" + RULE_NAME = "ValidExtrusionDirection" + + @staticmethod + def __call__(self): + + + assert IfcDotProduct(IfcDirection(DirectionRatios=[0.0,0.0,1.0]),self.ExtrudedDirection) != 0.0 + + + + + +class IfcExtrudedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + +class IfcFace_HasOuterBound: + SCOPE = "entity" + TYPE_NAME = "IfcFace" + RULE_NAME = "HasOuterBound" + + @staticmethod + def __call__(self): + bounds = self.Bounds + + assert (sizeof([temp for temp in bounds if 'ifc4.ifcfaceouterbound' in typeof(temp)])) <= 1 + + + + + +def calc_IfcFaceBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + + + + + + + + + + + + + + + + + + + +class IfcFan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFan_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcfantype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFanType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFanType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcFeatureElementSubtraction_HasNoSubtraction: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "HasNoSubtraction" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasOpenings) == 0 + + + + +class IfcFeatureElementSubtraction_IsNotFilling: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "IsNotFilling" + + @staticmethod + def __call__(self): + + + assert sizeof(self.FillsVoids) == 0 + + + + + +class IfcFillAreaStyle_MaxOneColour: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneColour" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4.ifccolour' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_MaxOneExtHatchStyle: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneExtHatchStyle" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4.ifcexternallydefinedhatchstyle' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_ConsistentHatchStyleDef: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "ConsistentHatchStyleDef" + + @staticmethod + def __call__(self): + + + assert IfcCorrectFillAreaStyle(self.FillStyles) + + + + + +class IfcFillAreaStyleHatching_PatternStart2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "PatternStart2D" + + @staticmethod + def __call__(self): + patternstart = self.PatternStart + + assert (not exists(patternstart)) or (patternstart.Dim == 2) + + + + +class IfcFillAreaStyleHatching_RefHatchLine2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "RefHatchLine2D" + + @staticmethod + def __call__(self): + pointofreferencehatchline = self.PointOfReferenceHatchLine + + assert (not exists(pointofreferencehatchline)) or (pointofreferencehatchline.Dim == 2) + + + + + + + + +class IfcFilter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFilter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcfiltertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFilterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFireSuppressionTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFireSuppressionTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcfiresuppressionterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFireSuppressionTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFixedReferenceSweptAreaSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcFixedReferenceSweptAreaSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4.ifcconic','ifc4.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + + + + + + + + + + + + + +class IfcFlowInstrument_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowInstrument_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcflowinstrumenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowInstrumentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrumentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFlowMeter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowMeter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcflowmetertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowMeterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFooting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFooting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcfootingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFootingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFootingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcFurniture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFurniture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcfurnituretype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFurnitureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurnitureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeographicElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcGeographicElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcgeographicelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcGeographicElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeometricCurveSet_NoSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricCurveSet" + RULE_NAME = "NoSurfaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Elements if 'ifc4.ifcsurface' in typeof(temp)])) == 0 + + + + + +class IfcGeometricRepresentationContext_North2D: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationContext" + RULE_NAME = "North2D" + + @staticmethod + def __call__(self): + truenorth = self.TrueNorth + + assert (not exists(truenorth)) or (hiindex(truenorth.DirectionRatios) == 2) + + + + + + + + +class IfcGeometricRepresentationSubContext_ParentNoSub: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "ParentNoSub" + + @staticmethod + def __call__(self): + parentcontext = self.ParentContext + + assert not 'ifc4.ifcgeometricrepresentationsubcontext' in typeof(parentcontext) + + + + +class IfcGeometricRepresentationSubContext_UserTargetProvided: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "UserTargetProvided" + + @staticmethod + def __call__(self): + targetview = self.TargetView + userdefinedtargetview = self.UserDefinedTargetView + + assert (targetview != IfcGeometricProjectionEnum.USERDEFINED) or ((targetview == IfcGeometricProjectionEnum.USERDEFINED) and exists(userdefinedtargetview)) + + + + +class IfcGeometricRepresentationSubContext_NoCoordOperation: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "NoCoordOperation" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasCoordinateOperation) == 0 + + + + +def calc_IfcGeometricRepresentationSubContext_WorldCoordinateSystem(self): + parentcontext = self.ParentContext + return \ + parentcontext.WorldCoordinateSystem + + + +def calc_IfcGeometricRepresentationSubContext_CoordinateSpaceDimension(self): + parentcontext = self.ParentContext + return \ + parentcontext.CoordinateSpaceDimension + + + +def calc_IfcGeometricRepresentationSubContext_TrueNorth(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.TrueNorth,IfcConvertDirectionInto2D(self.WorldCoordinateSystem.P[2 - 1])) + + + +def calc_IfcGeometricRepresentationSubContext_Precision(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.Precision,1) + + + + +class IfcGeometricSet_ConsistentDim: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricSet" + RULE_NAME = "ConsistentDim" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof([temp for temp in elements if temp.Dim != (elements[1 - 1].Dim)])) == 0 + + + + +def calc_IfcGeometricSet_Dim(self): + elements = self.Elements + return \ + elements[1 - 1].Dim + + + + +class IfcGrid_HasPlacement: + SCOPE = "entity" + TYPE_NAME = "IfcGrid" + RULE_NAME = "HasPlacement" + + @staticmethod + def __call__(self): + + + assert exists(self.ObjectPlacement) + + + + + +class IfcGridAxis_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + axiscurve = self.AxisCurve + + assert axiscurve.Dim == 2 + + + + +class IfcGridAxis_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + partofw = self.PartOfW + partofv = self.PartOfV + partofu = self.PartOfU + + assert (sizeof(partofu) == 1) ^ (sizeof(partofv) == 1) ^ (sizeof(partofw) == 1) + + + + + + + + + + + +def calc_IfcHalfSpaceSolid_Dim(self): + + return \ + 3 + + + + +class IfcHeatExchanger_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHeatExchanger_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcheatexchangertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHeatExchangerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchangerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcHumidifier_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHumidifier_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifchumidifiertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHumidifierType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifierType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + flangethickness = self.FlangeThickness + + assert (2. * flangethickness) < overalldepth + + + + +class IfcIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + webthickness = self.WebThickness + + assert webthickness < overallwidth + + + + +class IfcIShapeProfileDef_ValidFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFilletRadius" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + overalldepth = self.OverallDepth + webthickness = self.WebThickness + flangethickness = self.FlangeThickness + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or ((filletradius <= ((overallwidth - webthickness) / 2.)) and (filletradius <= ((overalldepth - (2. * flangethickness)) / 2.))) + + + + + + + + + + + +class IfcIndexedPolyCurve_Consecutive: + SCOPE = "entity" + TYPE_NAME = "IfcIndexedPolyCurve" + RULE_NAME = "Consecutive" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (sizeof(segments) == 0) or IfcConsecutiveSegments(segments) + + + + + + + + + + + + + + + + + +class IfcInterceptor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcInterceptor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcinterceptortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcInterceptorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIntersectionCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + +class IfcIntersectionCurve_DistinctSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "DistinctSurfaces" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) != (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + + + + + + + + + + + +class IfcJunctionBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcJunctionBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcjunctionboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcJunctionBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcLShapeProfileDef_ValidThickness: + SCOPE = "entity" + TYPE_NAME = "IfcLShapeProfileDef" + RULE_NAME = "ValidThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + thickness = self.Thickness + + assert (thickness < depth) and ((not exists(width)) or (thickness < width)) + + + + + +class IfcLaborResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcLaborResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +class IfcLamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifclamptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcLightFixture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLightFixture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifclightfixturetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLightFixtureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixtureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcLine_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcLine" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + pnt = self.Pnt + dir = self.Dir + + assert dir.Dim == pnt.Dim + + + + + +class IfcLocalPlacement_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcLocalPlacement" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + placementrelto = self.PlacementRelTo + relativeplacement = self.RelativePlacement + + assert IfcCorrectLocalPlacement(relativeplacement,placementrelto) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMaterialDefinitionRepresentation_OnlyStyledRepresentations: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialDefinitionRepresentation" + RULE_NAME = "OnlyStyledRepresentations" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4.ifcstyledrepresentation' in typeof(temp)])) == 0 + + + + + +class IfcMaterialLayer_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialLayer" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + +def calc_IfcMaterialLayerSet_TotalThickness(self): + + return \ + IfcMlsTotalThickness(self) + + + + + + + + + + + + + +class IfcMaterialProfile_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialProfile" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMechanicalFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMechanicalFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcmechanicalfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMechanicalFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMedicalDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMedicalDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcmedicaldevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMedicalDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMember_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMember_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcmembertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMemberStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcMemberStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4.ifcrelassociates.relatedobjects') if ('ifc4.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcMemberType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMemberType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcMirroredProfileDef_Operator(self): + + return \ + IfcCartesianTransformationOperator2D(Axis1=IfcDirection(DirectionRatios=[-1.,0.]), Axis2=IfcDirection(DirectionRatios=[0.,1.]), LocalOrigin=IfcCartesianPoint(Coordinates=[0.,0.]), Scale=1.) + + + + + + + +class IfcMotorConnection_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMotorConnection_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcmotorconnectiontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMotorConnectionType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnectionType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcNamedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcNamedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert IfcCorrectDimensions(self.UnitType,self.Dimensions) + + + + + +class IfcObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + isdefinedby = self.IsDefinedBy + + assert (sizeof(isdefinedby) == 0) or IfcUniqueDefinitionNames(isdefinedby) + + + + + + + + + + + +class IfcObjective_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcObjective" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + objectivequalifier = self.ObjectiveQualifier + + assert (objectivequalifier != IfcObjectiveEnum.USERDEFINED) or ((objectivequalifier == IfcObjectiveEnum.USERDEFINED) and exists(self.UserDefinedQualifier)) + + + + + +class IfcOccupant_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcOccupant" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not predefinedtype == IfcOccupantTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcOffsetCurve2D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve2D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 2 + + + + + +class IfcOffsetCurve3D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve3D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 3 + + + + + + + + + + + + + + + + + + + + +class IfcOrientedEdge_EdgeElementNotOriented: + SCOPE = "entity" + TYPE_NAME = "IfcOrientedEdge" + RULE_NAME = "EdgeElementNotOriented" + + @staticmethod + def __call__(self): + edgeelement = self.EdgeElement + + assert not 'ifc4.ifcorientededge' in typeof(edgeelement) + + + + +def calc_IfcOrientedEdge_EdgeStart(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeStart,edgeelement.EdgeEnd) + + + +def calc_IfcOrientedEdge_EdgeEnd(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeEnd,edgeelement.EdgeStart) + + + + + + + +class IfcOutlet_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcOutlet_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcoutlettype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcOutletType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutletType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcOwnerHistory_CorrectChangeAction: + SCOPE = "entity" + TYPE_NAME = "IfcOwnerHistory" + RULE_NAME = "CorrectChangeAction" + + @staticmethod + def __call__(self): + changeaction = self.ChangeAction + lastmodifieddate = self.LastModifiedDate + + assert exists(lastmodifieddate) or ((not exists(lastmodifieddate)) and (not exists(changeaction))) or ((not exists(lastmodifieddate)) and exists(changeaction) and ((changeaction == IfcChangeActionEnum.NOTDEFINED) or (changeaction == IfcChangeActionEnum.NOCHANGE))) + + + + + + + + +class IfcPath_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcPath" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcPathHeadToTail(self) + + + + + +class IfcPcurve_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcPcurve" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + referencecurve = self.ReferenceCurve + + assert referencecurve.Dim == 2 + + + + + + + + + + + + + + +class IfcPerson_IdentifiablePerson: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "IdentifiablePerson" + + @staticmethod + def __call__(self): + identification = self.Identification + familyname = self.FamilyName + givenname = self.GivenName + + assert exists(identification) or exists(familyname) or exists(givenname) + + + + +class IfcPerson_ValidSetOfNames: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "ValidSetOfNames" + + @staticmethod + def __call__(self): + familyname = self.FamilyName + givenname = self.GivenName + middlenames = self.MiddleNames + + assert (not exists(middlenames)) or exists(familyname) or exists(givenname) + + + + + + + + +class IfcPhysicalComplexQuantity_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert (sizeof([temp for temp in hasquantities if self == temp])) == 0 + + + + +class IfcPhysicalComplexQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert IfcUniqueQuantityNames(hasquantities) + + + + + + + + + + + +class IfcPile_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPile_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcpiletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPileType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPileType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcpipefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcpipesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPixelTexture_MinPixelInS: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInS" + + @staticmethod + def __call__(self): + width = self.Width + + assert width >= 1 + + + + +class IfcPixelTexture_MinPixelInT: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInT" + + @staticmethod + def __call__(self): + height = self.Height + + assert height >= 1 + + + + +class IfcPixelTexture_NumberOfColours: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "NumberOfColours" + + @staticmethod + def __call__(self): + colourcomponents = self.ColourComponents + + assert 1 <= colourcomponents <= 4 + + + + +class IfcPixelTexture_SizeOfPixelList: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "SizeOfPixelList" + + @staticmethod + def __call__(self): + width = self.Width + height = self.Height + pixel = self.Pixel + + assert sizeof(pixel) == (width * height) + + + + +class IfcPixelTexture_PixelAsByteAndSameLength: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "PixelAsByteAndSameLength" + + @staticmethod + def __call__(self): + pixel = self.Pixel + + assert (sizeof([temp for temp in pixel if ((blength(temp) % 8) == 0) and (blength(temp) == (blength(pixel[1 - 1])))])) == sizeof(pixel) + + + + + +def calc_IfcPlacement_Dim(self): + location = self.Location + return \ + location.Dim + + + + + + + + + + + + + +class IfcPlate_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPlate_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcplatetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPlateStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcPlateStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4.ifcrelassociates.relatedobjects') if ('ifc4.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcPlateType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlateType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcPointOnCurve_Dim(self): + basiscurve = self.BasisCurve + return \ + basiscurve.Dim + + + + +def calc_IfcPointOnSurface_Dim(self): + basissurface = self.BasisSurface + return \ + basissurface.Dim + + + + +class IfcPolyLoop_AllPointsSameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyLoop" + RULE_NAME = "AllPointsSameDim" + + @staticmethod + def __call__(self): + polygon = self.Polygon + + assert (sizeof([temp for temp in polygon if temp.Dim != (polygon[1 - 1].Dim)])) == 0 + + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryDim" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert polygonalboundary.Dim == 2 + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryType: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryType" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert (sizeof(typeof(polygonalboundary) * ['ifc4.ifcpolyline','ifc4.ifccompositecurve'])) == 1 + + + + + + + + +class IfcPolyline_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyline" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + points = self.Points + + assert (sizeof([temp for temp in points if temp.Dim != (points[1 - 1].Dim)])) == 0 + + + + + + + + +class IfcPostalAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPostalAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + internallocation = self.InternalLocation + addresslines = self.AddressLines + postalbox = self.PostalBox + town = self.Town + region = self.Region + postalcode = self.PostalCode + country = self.Country + + assert exists(internallocation) or exists(addresslines) or exists(postalbox) or exists(postalcode) or exists(town) or exists(region) or exists(country) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPresentationLayerAssignment_ApplicableItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerAssignment" + RULE_NAME = "ApplicableItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4.ifcshaperepresentation','ifc4.ifcgeometricrepresentationitem','ifc4.ifcmappeditem'])) == 1])) == sizeof(assigneditems) + + + + + +class IfcPresentationLayerWithStyle_ApplicableOnlyToItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerWithStyle" + RULE_NAME = "ApplicableOnlyToItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4.ifcgeometricrepresentationitem','ifc4.ifcmappeditem'])) == 1])) == sizeof(assigneditems) + + + + + + + + + + + +class IfcProcedure_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProcedure_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcProcedureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + + + + +class IfcProduct_PlacementForShapeRepresentation: + SCOPE = "entity" + TYPE_NAME = "IfcProduct" + RULE_NAME = "PlacementForShapeRepresentation" + + @staticmethod + def __call__(self): + objectplacement = self.ObjectPlacement + representation = self.Representation + + assert (exists(representation) and exists(objectplacement)) or (exists(representation) and ((sizeof([temp for temp in representation.Representations if 'ifc4.ifcshaperepresentation' in typeof(temp)])) == 0)) or (not exists(representation)) + + + + + +class IfcProductDefinitionShape_OnlyShapeModel: + SCOPE = "entity" + TYPE_NAME = "IfcProductDefinitionShape" + RULE_NAME = "OnlyShapeModel" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4.ifcshapemodel' in typeof(temp)])) == 0 + + + + + + + + + + + + + + +class IfcProject_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProject_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert (not exists(self.RepresentationContexts)) or ((sizeof([temp for temp in self.RepresentationContexts if 'ifc4.ifcgeometricrepresentationsubcontext' in typeof(temp)])) == 0) + + + + +class IfcProject_NoDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "NoDecomposition" + + @staticmethod + def __call__(self): + + + assert sizeof(self.Decomposes) == 0 + + + + + + + + + + + +class IfcProjectedCRS_IsLengthUnit: + SCOPE = "entity" + TYPE_NAME = "IfcProjectedCRS" + RULE_NAME = "IsLengthUnit" + + @staticmethod + def __call__(self): + mapunit = self.MapUnit + + assert (not exists(mapunit)) or (mapunit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + + + + + + + + + + + +class IfcPropertyBoundedValue_SameUnitUpperLower: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperLower" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + lowerboundvalue = self.LowerBoundValue + + assert (not exists(upperboundvalue)) or (not exists(lowerboundvalue)) or (typeof(upperboundvalue) == typeof(lowerboundvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitUpperSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperSet" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(upperboundvalue)) or (not exists(setpointvalue)) or (typeof(upperboundvalue) == typeof(setpointvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitLowerSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitLowerSet" + + @staticmethod + def __call__(self): + lowerboundvalue = self.LowerBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(lowerboundvalue)) or (not exists(setpointvalue)) or (typeof(lowerboundvalue) == typeof(setpointvalue)) + + + + + + + + +class IfcPropertyDependencyRelationship_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyDependencyRelationship" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + dependingproperty = self.DependingProperty + dependantproperty = self.DependantProperty + + assert dependingproperty != dependantproperty + + + + + +class IfcPropertyEnumeratedValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeratedValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + enumerationvalues = self.EnumerationValues + enumerationreference = self.EnumerationReference + + assert (not exists(enumerationreference)) or (not exists(enumerationvalues)) or ((sizeof([temp for temp in enumerationvalues if temp in enumerationreference.EnumerationValues])) == sizeof(enumerationvalues)) + + + + + +class IfcPropertyEnumeration_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeration" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.EnumerationValues if not (typeof(self.EnumerationValues[1 - 1])) == typeof(temp)])) == 0 + + + + + +class IfcPropertyListValue_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyListValue" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.ListValues if not (typeof(self.ListValues[1 - 1])) == typeof(temp)])) == 0 + + + + + + + + +class IfcPropertySet_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySet_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + + + + +class IfcPropertySetTemplate_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySetTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + + + + + +class IfcPropertyTableValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + definedvalues = self.DefinedValues + + assert ((not exists(definingvalues)) and (not exists(definedvalues))) or (sizeof(definingvalues) == sizeof(definedvalues)) + + + + +class IfcPropertyTableValue_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + + assert (not exists(definingvalues)) or ((sizeof([temp for temp in self.DefiningValues if typeof(temp) != (typeof(self.DefiningValues[1 - 1]))])) == 0) + + + + +class IfcPropertyTableValue_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + definedvalues = self.DefinedValues + + assert (not exists(definedvalues)) or ((sizeof([temp for temp in self.DefinedValues if typeof(temp) != (typeof(self.DefinedValues[1 - 1]))])) == 0) + + + + + + + + + + + +class IfcProtectiveDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcprotectivedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcprotectivedevicetrippingunittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProtectiveDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProxy_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcProxy" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcPump_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPump_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcpumptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPumpType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPumpType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcQuantityArea_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.AREAUNIT) + + + + +class IfcQuantityArea_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + areavalue = self.AreaValue + + assert areavalue >= 0. + + + + + +class IfcQuantityCount_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityCount" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + countvalue = self.CountValue + + assert countvalue >= 0. + + + + + +class IfcQuantityLength_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + +class IfcQuantityLength_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + lengthvalue = self.LengthValue + + assert lengthvalue >= 0. + + + + + + + + +class IfcQuantityTime_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.TIMEUNIT) + + + + +class IfcQuantityTime_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + timevalue = self.TimeValue + + assert timevalue >= 0. + + + + + +class IfcQuantityVolume_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.VOLUMEUNIT) + + + + +class IfcQuantityVolume_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + volumevalue = self.VolumeValue + + assert volumevalue >= 0. + + + + + +class IfcQuantityWeight_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.MASSUNIT) + + + + +class IfcQuantityWeight_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + weightvalue = self.WeightValue + + assert weightvalue >= 0. + + + + + +class IfcRailing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRailing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcrailingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcramptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRampFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcrampflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRationalBSplineCurveWithKnots_SameNumOfWeightsAndPoints: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "SameNumOfWeightsAndPoints" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert sizeof(weightsdata) == sizeof(self.ControlPointsList) + + + + +class IfcRationalBSplineCurveWithKnots_WeightsGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "WeightsGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcCurveWeightsPositive(self) + + + + +def calc_IfcRationalBSplineCurveWithKnots_Weights(self): + weightsdata = self.WeightsData + return \ + IfcListToArray(weightsdata,0,self.UpperIndexOnControlPoints) + + + + +class IfcRationalBSplineSurfaceWithKnots_CorrespondingWeightsDataLists: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingWeightsDataLists" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert (sizeof(weightsdata) == sizeof(self.ControlPointsList)) and ((sizeof(weightsdata[1 - 1])) == (sizeof(self.ControlPointsList[1 - 1]))) + + + + +class IfcRationalBSplineSurfaceWithKnots_WeightValuesGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "WeightValuesGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcSurfaceWeightsPositive(self) + + + + +def calc_IfcRationalBSplineSurfaceWithKnots_Weights(self): + uupper = self.UUpper + vupper = self.VUpper + weightsdata = self.WeightsData + return \ + IfcMakeArrayOfArray(weightsdata,0,uupper,0,vupper) + + + + +class IfcRectangleHollowProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert (wallthickness < (self.XDim / 2.)) and (wallthickness < (self.YDim / 2.)) + + + + +class IfcRectangleHollowProfileDef_ValidInnerRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidInnerRadius" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + innerfilletradius = self.InnerFilletRadius + + assert (not exists(innerfilletradius)) or ((innerfilletradius <= ((self.XDim / 2.) - wallthickness)) and (innerfilletradius <= ((self.YDim / 2.) - wallthickness))) + + + + +class IfcRectangleHollowProfileDef_ValidOuterRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidOuterRadius" + + @staticmethod + def __call__(self): + outerfilletradius = self.OuterFilletRadius + + assert (not exists(outerfilletradius)) or ((outerfilletradius <= (self.XDim / 2.)) and (outerfilletradius <= (self.YDim / 2.))) + + + + + + + + + + + +class IfcRectangularTrimmedSurface_U1AndU2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "U1AndU2Different" + + @staticmethod + def __call__(self): + u1 = self.U1 + u2 = self.U2 + + assert u1 != u2 + + + + +class IfcRectangularTrimmedSurface_V1AndV2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "V1AndV2Different" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + + assert v1 != v2 + + + + +class IfcRectangularTrimmedSurface_UsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "UsenseCompatible" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + u1 = self.U1 + u2 = self.U2 + usense = self.Usense + + assert (('ifc4.ifcelementarysurface' in typeof(basissurface)) and (not 'ifc4.ifcplane' in typeof(basissurface))) or ('ifc4.ifcsurfaceofrevolution' in typeof(basissurface)) or (usense == (u2 > u1)) + + + + +class IfcRectangularTrimmedSurface_VsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "VsenseCompatible" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + vsense = self.Vsense + + assert vsense == (v2 > v1) + + + + + + + + + + + + + + + + + + + + +class IfcReinforcingBar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingBar_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcreinforcingbartype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingBarType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + +class IfcReinforcingBarType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + + + + + + + + +class IfcReinforcingMesh_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingMesh_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcreinforcingmeshtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingMeshType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + +class IfcReinforcingMeshType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + + +class IfcRelAggregates_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAggregates" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelAssigns_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssigns" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatedobjects = self.RelatedObjects + relatedobjectstype = self.RelatedObjectsType + + assert IfcCorrectObjectAssignment(relatedobjectstype,relatedobjects) + + + + + +class IfcRelAssignsToActor_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToActor" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingactor = self.RelatingActor + + assert (sizeof([temp for temp in self.RelatedObjects if relatingactor == temp])) == 0 + + + + + +class IfcRelAssignsToControl_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToControl" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontrol = self.RelatingControl + + assert (sizeof([temp for temp in self.RelatedObjects if relatingcontrol == temp])) == 0 + + + + + +class IfcRelAssignsToGroup_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToGroup" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatinggroup = self.RelatingGroup + + assert (sizeof([temp for temp in self.RelatedObjects if relatinggroup == temp])) == 0 + + + + + + + + +class IfcRelAssignsToProcess_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProcess" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + + assert (sizeof([temp for temp in self.RelatedObjects if relatingprocess == temp])) == 0 + + + + + +class IfcRelAssignsToProduct_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProduct" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingproduct = self.RelatingProduct + + assert (sizeof([temp for temp in self.RelatedObjects if relatingproduct == temp])) == 0 + + + + + +class IfcRelAssignsToResource_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToResource" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingresource = self.RelatingResource + + assert (sizeof([temp for temp in self.RelatedObjects if relatingresource == temp])) == 0 + + + + + + + + + + + + + + + + + + + + + + + +class IfcRelAssociatesMaterial_NoVoidElement: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "NoVoidElement" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if ('ifc4.ifcfeatureelementsubtraction' in typeof(temp)) or ('ifc4.ifcvirtualelement' in typeof(temp))])) == 0 + + + + +class IfcRelAssociatesMaterial_AllowedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "AllowedElements" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if (sizeof(typeof(temp) * ['ifc4.ifcelement','ifc4.ifcelementtype','ifc4.ifcwindowstyle','ifc4.ifcdoorstyle','ifc4.ifcstructuralmember','ifc4.ifcport'])) == 0])) == 0 + + + + + + + + +class IfcRelConnectsElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelConnectsPathElements_NormalizedRelatingPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatingPriorities" + + @staticmethod + def __call__(self): + relatingpriorities = self.RelatingPriorities + + assert (sizeof(relatingpriorities) == 0) or ((sizeof([temp for temp in relatingpriorities if 0 <= temp <= 100])) == sizeof(relatingpriorities)) + + + + +class IfcRelConnectsPathElements_NormalizedRelatedPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatedPriorities" + + @staticmethod + def __call__(self): + relatedpriorities = self.RelatedPriorities + + assert (sizeof(relatedpriorities) == 0) or ((sizeof([temp for temp in relatedpriorities if 0 <= temp <= 100])) == sizeof(relatedpriorities)) + + + + + + + + +class IfcRelConnectsPorts_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPorts" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingport = self.RelatingPort + relatedport = self.RelatedPort + + assert relatingport != relatedport + + + + + + + + + + + + + + + + + +class IfcRelContainedInSpatialStructure_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRelContainedInSpatialStructure" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if 'ifc4.ifcspatialstructureelement' in typeof(temp)])) == 0 + + + + + + + + + + + +class IfcRelDeclares_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelDeclares" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontext = self.RelatingContext + relateddefinitions = self.RelatedDefinitions + + assert (sizeof([temp for temp in relateddefinitions if relatingcontext == temp])) == 0 + + + + + + + + + + + + + + +class IfcRelDefinesByProperties_NoRelatedTypeObject: + SCOPE = "entity" + TYPE_NAME = "IfcRelDefinesByProperties" + RULE_NAME = "NoRelatedTypeObject" + + @staticmethod + def __call__(self): + + + assert (sizeof([types for types in self.RelatedObjects if 'ifc4.ifctypeobject' in typeof(types)])) == 0 + + + + + + + + + + + + + + + + + +class IfcRelInterferesElements_NotSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelInterferesElements" + RULE_NAME = "NotSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelNests_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelNests" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + + + + +class IfcRelReferencedInSpatialStructure_AllowedRelatedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelReferencedInSpatialStructure" + RULE_NAME = "AllowedRelatedElements" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if ('ifc4.ifcspatialstructureelement' in typeof(temp)) and (not 'ifc4.ifcspace' in typeof(temp))])) == 0 + + + + + +class IfcRelSequence_AvoidInconsistentSequence: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "AvoidInconsistentSequence" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + relatedprocess = self.RelatedProcess + + assert relatingprocess != relatedprocess + + + + +class IfcRelSequence_CorrectSequenceType: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "CorrectSequenceType" + + @staticmethod + def __call__(self): + sequencetype = self.SequenceType + userdefinedsequencetype = self.UserDefinedSequenceType + + assert (sequencetype != IfcSequenceEnum.USERDEFINED) or ((sequencetype == IfcSequenceEnum.USERDEFINED) and exists(userdefinedsequencetype)) + + + + + + + + +class IfcRelSpaceBoundary_CorrectPhysOrVirt: + SCOPE = "entity" + TYPE_NAME = "IfcRelSpaceBoundary" + RULE_NAME = "CorrectPhysOrVirt" + + @staticmethod + def __call__(self): + relatedbuildingelement = self.RelatedBuildingElement + physicalorvirtualboundary = self.PhysicalOrVirtualBoundary + + assert ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Physical) and (not 'ifc4.ifcvirtualelement' in typeof(relatedbuildingelement))) or ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Virtual) and (('ifc4.ifcvirtualelement' in typeof(relatedbuildingelement)) or ('ifc4.ifcopeningelement' in typeof(relatedbuildingelement)))) or (physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.NotDefined) + + + + + + + + + + + + + + + + + +class IfcReparametrisedCompositeCurveSegment_PositiveLengthParameter: + SCOPE = "entity" + TYPE_NAME = "IfcReparametrisedCompositeCurveSegment" + RULE_NAME = "PositiveLengthParameter" + + @staticmethod + def __call__(self): + paramlength = self.ParamLength + + assert paramlength > 0.0 + + + + + + + + + + + + + + +class IfcRepresentationMap_ApplicableMappedRepr: + SCOPE = "entity" + TYPE_NAME = "IfcRepresentationMap" + RULE_NAME = "ApplicableMappedRepr" + + @staticmethod + def __call__(self): + mappedrepresentation = self.MappedRepresentation + + assert 'ifc4.ifcshapemodel' in typeof(mappedrepresentation) + + + + + + + + + + + + + + + + + + + + +class IfcRevolvedAreaSolid_AxisStartInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisStartInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Location.Coordinates[3 - 1]) == 0.0 + + + + +class IfcRevolvedAreaSolid_AxisDirectionInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisDirectionInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Z.DirectionRatios[3 - 1]) == 0.0 + + + + +def calc_IfcRevolvedAreaSolid_AxisLine(self): + axis = self.Axis + return \ + IfcLine(Pnt=axis.Location, Dir=IfcVector(Orientation=axis.Z, Magnitude=1.0)) + + + + +class IfcRevolvedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + + + + + + + +class IfcRoof_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRoof_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcrooftype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRoofType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoofType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcRoundedRectangleProfileDef_ValidRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRoundedRectangleProfileDef" + RULE_NAME = "ValidRadius" + + @staticmethod + def __call__(self): + roundingradius = self.RoundingRadius + + assert (roundingradius <= (self.XDim / 2.)) and (roundingradius <= (self.YDim / 2.)) + + + + + +def calc_IfcSIUnit_Dimensions(self): + + return \ + IfcDimensionsForSiUnit(self.Name) + + + + +class IfcSanitaryTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSanitaryTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcsanitaryterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSanitaryTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSeamCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + +class IfcSeamCurve_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) == (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + + + + + + + + +class IfcSectionedSpine_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSpine_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSpine_SpineCurveDim: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "SpineCurveDim" + + @staticmethod + def __call__(self): + spinecurve = self.SpineCurve + + assert spinecurve.Dim == 3 + + + + +def calc_IfcSectionedSpine_Dim(self): + + return \ + 3 + + + + +class IfcSensor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSensor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcsensortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSensorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcShadingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcShadingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcshadingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcShadingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcShapeModel_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcShapeModel" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + ofshapeaspect = self.OfShapeAspect + + assert (sizeof(self.OfProductRepresentation) == 1) ^ (sizeof(self.RepresentationMap) == 1) ^ (sizeof(ofshapeaspect) == 1) + + + + + +class IfcShapeRepresentation_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert 'ifc4.ifcgeometricrepresentationcontext' in typeof(self.ContextOfItems) + + + + +class IfcShapeRepresentation_NoTopologicalItem: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "NoTopologicalItem" + + @staticmethod + def __call__(self): + items = self.Items + + assert (sizeof([temp for temp in items if ('ifc4.ifctopologicalrepresentationitem' in typeof(temp)) and (not (sizeof(['ifc4.ifcvertexpoint','ifc4.ifcedgecurve','ifc4.ifcfacesurface'] * typeof(temp))) == 1)])) == 0 + + + + +class IfcShapeRepresentation_HasRepresentationType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationType" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcShapeRepresentation_HasRepresentationIdentifier: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationIdentifier" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationIdentifier) + + + + +class IfcShapeRepresentation_CorrectItemsForType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectItemsForType" + + @staticmethod + def __call__(self): + + + assert IfcShapeRepresentationTypes(self.RepresentationType,self.Items) + + + + + +def calc_IfcShellBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + + + + + + + + + + +class IfcSlab_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSlab_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcslabtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSlabElementedCase_HasDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcSlabElementedCase" + RULE_NAME = "HasDecomposition" + + @staticmethod + def __call__(self): + + + assert hiindex(self.IsDecomposedBy) > 0 + + + + + +class IfcSlabStandardCase_HasMaterialLayerSetusage: + SCOPE = "entity" + TYPE_NAME = "IfcSlabStandardCase" + RULE_NAME = "HasMaterialLayerSetusage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4.ifcrelassociates.relatedobjects') if ('ifc4.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcSlabType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlabType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSolarDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSolarDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcsolardevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSolarDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcSolidModel_Dim(self): + + return \ + 3 + + + + +class IfcSpace_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpace_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcspacetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeater_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpaceHeater_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcspaceheatertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeaterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeaterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSpaceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcSpatialStructureElement_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialStructureElement" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + + + assert (hiindex(self.Decomposes) == 1) and ('ifc4.ifcrelaggregates' in (typeof(self.Decomposes[1 - 1]))) and (('ifc4.ifcproject' in (typeof(self.Decomposes[1 - 1].RelatingObject))) or ('ifc4.ifcspatialstructureelement' in (typeof(self.Decomposes[1 - 1].RelatingObject)))) + + + + + + + + +class IfcSpatialZone_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpatialZone_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcspatialzonetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpatialZoneType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZoneType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcStackTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStackTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcstackterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStackTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStair_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStair_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcstairtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStairFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcstairflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStairType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcStructuralAnalysisModel_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralAnalysisModel" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAnalysisModelTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + + + + +class IfcStructuralCurveAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralCurveAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveAction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert predefinedtype != IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + + + + + + + +class IfcStructuralCurveMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralCurveReaction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveReaction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.SINUS) and (predefinedtype != IfcStructuralCurveActivityTypeEnum.PARABOLA) + + + + + + + + +class IfcStructuralLinearAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4.ifcstructuralloadlinearforce','ifc4.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + +class IfcStructuralLinearAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralCurveActivityTypeEnum.CONST + + + + + + + + +class IfcStructuralLoadCase_IsLoadCasePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadCase" + RULE_NAME = "IsLoadCasePredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcLoadGroupTypeEnum.LOAD_CASE + + + + + +class IfcStructuralLoadConfiguration_ValidListSize: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadConfiguration" + RULE_NAME = "ValidListSize" + + @staticmethod + def __call__(self): + values = self.Values + locations = self.Locations + + assert (not exists(locations)) or (sizeof(locations) == sizeof(values)) + + + + + +class IfcStructuralLoadGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + actiontype = self.ActionType + actionsource = self.ActionSource + + assert ((predefinedtype != IfcLoadGroupTypeEnum.USERDEFINED) and (actiontype != IfcActionTypeEnum.USERDEFINED) and (actionsource != IfcActionSourceTypeEnum.USERDEFINED)) or exists(self.ObjectType) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcStructuralPlanarAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4.ifcstructuralloadplanarforce','ifc4.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + +class IfcStructuralPlanarAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralSurfaceActivityTypeEnum.CONST + + + + + +class IfcStructuralPointAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4.ifcstructuralloadsingleforce','ifc4.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralPointReaction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointReaction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4.ifcstructuralloadsingleforce','ifc4.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralResultGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralResultGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + theorytype = self.TheoryType + + assert (theorytype != IfcAnalysisTheoryTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcStructuralSurfaceAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralSurfaceAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceReaction_HasPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceReaction" + RULE_NAME = "HasPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStyledItem_ApplicableItem: + SCOPE = "entity" + TYPE_NAME = "IfcStyledItem" + RULE_NAME = "ApplicableItem" + + @staticmethod + def __call__(self): + item = self.Item + + assert not 'ifc4.ifcstyleditem' in typeof(item) + + + + + +class IfcStyledRepresentation_OnlyStyledItems: + SCOPE = "entity" + TYPE_NAME = "IfcStyledRepresentation" + RULE_NAME = "OnlyStyledItems" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4.ifcstyleditem' in typeof(temp)])) == 0 + + + + + +class IfcSubContractResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcSubContractResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +def calc_IfcSurface_Dim(self): + + return \ + 3 + + + + +class IfcSurfaceCurve_CurveIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIs3D" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert curve3d.Dim == 3 + + + + +class IfcSurfaceCurve_CurveIsNotPcurve: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIsNotPcurve" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert not 'ifc4.ifcpcurve' in typeof(curve3d) + + + + +def calc_IfcSurfaceCurve_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + +class IfcSurfaceCurveSweptAreaSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurveSweptAreaSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4.ifcconic','ifc4.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + +class IfcSurfaceFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSurfaceFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcSurfaceOfLinearExtrusion_DepthGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceOfLinearExtrusion" + RULE_NAME = "DepthGreaterZero" + + @staticmethod + def __call__(self): + depth = self.Depth + + assert depth > 0. + + + + +def calc_IfcSurfaceOfLinearExtrusion_ExtrusionAxis(self): + extrudeddirection = self.ExtrudedDirection + depth = self.Depth + return \ + IfcVector(Orientation=extrudeddirection, Magnitude=depth) + + + + +def calc_IfcSurfaceOfRevolution_AxisLine(self): + axisposition = self.AxisPosition + return \ + IfcLine(Pnt=axisposition.Location, Dir=IfcVector(Orientation=axisposition.Z, Magnitude=1.0)) + + + + +class IfcSurfaceReinforcementArea_SurfaceAndOrShearAreaSpecified: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "SurfaceAndOrShearAreaSpecified" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + surfacereinforcement2 = self.SurfaceReinforcement2 + shearreinforcement = self.ShearReinforcement + + assert exists(surfacereinforcement1) or exists(surfacereinforcement2) or exists(shearreinforcement) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea1: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea1" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + + assert (not exists(surfacereinforcement1)) or (((surfacereinforcement1[1 - 1]) >= 0.) and ((surfacereinforcement1[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement1) == 1) or ((surfacereinforcement1[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea2: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea2" + + @staticmethod + def __call__(self): + surfacereinforcement2 = self.SurfaceReinforcement2 + + assert (not exists(surfacereinforcement2)) or (((surfacereinforcement2[1 - 1]) >= 0.) and ((surfacereinforcement2[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement2) == 1) or ((surfacereinforcement2[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea3: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea3" + + @staticmethod + def __call__(self): + shearreinforcement = self.ShearReinforcement + + assert (not exists(shearreinforcement)) or (shearreinforcement >= 0.) + + + + + +class IfcSurfaceStyle_MaxOneShading: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneShading" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4.ifcsurfacestyleshading' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneLighting: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneLighting" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4.ifcsurfacestylelighting' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneRefraction: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneRefraction" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4.ifcsurfacestylerefraction' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneTextures: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneTextures" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4.ifcsurfacestylewithtextures' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneExtDefined: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneExtDefined" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4.ifcexternallydefinedsurfacestyle' in typeof(style)])) <= 1 + + + + + + + + + + + + + + + + + + + + + + + +class IfcSweptAreaSolid_SweptAreaType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptAreaSolid" + RULE_NAME = "SweptAreaType" + + @staticmethod + def __call__(self): + sweptarea = self.SweptArea + + assert sweptarea.ProfileType == IfcProfileTypeEnum.Area + + + + + +class IfcSweptDiskSolid_DirectrixDim: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixDim" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSweptDiskSolid_InnerRadiusSize: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "InnerRadiusSize" + + @staticmethod + def __call__(self): + radius = self.Radius + innerradius = self.InnerRadius + + assert (not exists(innerradius)) or (radius > innerradius) + + + + +class IfcSweptDiskSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4.ifcconic','ifc4.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + +class IfcSweptDiskSolidPolygonal_CorrectRadii: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "CorrectRadii" + + @staticmethod + def __call__(self): + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or (filletradius >= self.Radius) + + + + +class IfcSweptDiskSolidPolygonal_DirectrixIsPolyline: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "DirectrixIsPolyline" + + @staticmethod + def __call__(self): + + + assert ('ifc4.ifcpolyline' in typeof(self.Directrix)) or (('ifc4.ifcindexedpolycurve' in typeof(self.Directrix)) and (not exists(self.Directrix.Segments))) + + + + + +class IfcSweptSurface_SweptCurveType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptSurface" + RULE_NAME = "SweptCurveType" + + @staticmethod + def __call__(self): + sweptcurve = self.SweptCurve + + assert sweptcurve.ProfileType == IfcProfileTypeEnum.Curve + + + + + +class IfcSwitchingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSwitchingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcswitchingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSwitchingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSystemFurnitureElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSystemFurnitureElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcsystemfurnitureelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSystemFurnitureElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < depth + + + + +class IfcTShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcTable_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + rows = self.Rows + + assert (sizeof([temp for temp in rows if hiindex(temp.RowCells) != (hiindex(rows[1 - 1].RowCells))])) == 0 + + + + +class IfcTable_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + numberofheadings = self.NumberOfHeadings + + assert 0 <= numberofheadings <= 1 + + + + +def calc_IfcTable_NumberOfCellsInRow(self): + rows = self.Rows + return \ + hiindex(rows[1 - 1].RowCells) + + + +def calc_IfcTable_NumberOfHeadings(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if temp.IsHeading]) + + + +def calc_IfcTable_NumberOfDataRows(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if not temp.IsHeading]) + + + + + + + + + + +class IfcTank_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTank_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifctanktype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTankType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTankType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTask_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTask_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcTaskType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTaskType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + +class IfcTelecomAddress_MinimumDataProvided: + SCOPE = "entity" + TYPE_NAME = "IfcTelecomAddress" + RULE_NAME = "MinimumDataProvided" + + @staticmethod + def __call__(self): + telephonenumbers = self.TelephoneNumbers + facsimilenumbers = self.FacsimileNumbers + pagernumber = self.PagerNumber + electronicmailaddresses = self.ElectronicMailAddresses + wwwhomepageurl = self.WWWHomePageURL + messagingids = self.MessagingIDs + + assert exists(telephonenumbers) or exists(facsimilenumbers) or exists(pagernumber) or exists(electronicmailaddresses) or exists(wwwhomepageurl) or exists(messagingids) + + + + + +class IfcTendon_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendon_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifctendontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonAnchor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifctendonanchortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcTessellatedFaceSet_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcTextLiteralWithExtent_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcTextLiteralWithExtent" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + extent = self.Extent + + assert not 'ifc4.ifcplanarbox' in typeof(extent) + + + + + + + + +class IfcTextStyleFontModel_MeasureOfFontSize: + SCOPE = "entity" + TYPE_NAME = "IfcTextStyleFontModel" + RULE_NAME = "MeasureOfFontSize" + + @staticmethod + def __call__(self): + + + assert ('ifc4.ifclengthmeasure' in typeof(self.FontSize)) and (self.FontSize > 0.) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTopologyRepresentation_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4.ifctopologicalrepresentationitem' in typeof(temp)])) == 0 + + + + +class IfcTopologyRepresentation_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcTopologyRepresentation_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + + + assert IfcTopologyRepresentationTypes(self.RepresentationType,self.Items) + + + + + +class IfcToroidalSurface_MajorLargerMinor: + SCOPE = "entity" + TYPE_NAME = "IfcToroidalSurface" + RULE_NAME = "MajorLargerMinor" + + @staticmethod + def __call__(self): + majorradius = self.MajorRadius + minorradius = self.MinorRadius + + assert minorradius < majorradius + + + + + +class IfcTransformer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransformer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifctranformertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransformerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTransportElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransportElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransportElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransportElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifctransportelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransportElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransportElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransportElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcTriangulatedFaceSet_NumberOfTriangles(self): + coordindex = self.CoordIndex + return \ + sizeof(coordindex) + + + + +class IfcTrimmedCurve_Trim1ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim1ValuesConsistent" + + @staticmethod + def __call__(self): + trim1 = self.Trim1 + + assert (hiindex(trim1) == 1) or ((typeof(trim1[1 - 1])) != (typeof(trim1[2 - 1]))) + + + + +class IfcTrimmedCurve_Trim2ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim2ValuesConsistent" + + @staticmethod + def __call__(self): + trim2 = self.Trim2 + + assert (hiindex(trim2) == 1) or ((typeof(trim2[1 - 1])) != (typeof(trim2[2 - 1]))) + + + + +class IfcTrimmedCurve_NoTrimOfBoundedCurves: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "NoTrimOfBoundedCurves" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert not 'ifc4.ifcboundedcurve' in typeof(basiscurve) + + + + + +class IfcTubeBundle_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTubeBundle_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifctubebundletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTubeBundleType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundleType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTypeObject_NameRequired: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "NameRequired" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTypeObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + haspropertysets = self.HasPropertySets + + assert (not exists(haspropertysets)) or IfcUniquePropertySetNames(haspropertysets) + + + + + + + + +class IfcTypeProduct_ApplicableOccurrence: + SCOPE = "entity" + TYPE_NAME = "IfcTypeProduct" + RULE_NAME = "ApplicableOccurrence" + + @staticmethod + def __call__(self): + + + assert (not exists(lambda: self.Types[1 - 1])) or ((sizeof([temp for temp in self.Types[1 - 1].RelatedObjects if not 'ifc4.ifcproduct' in typeof(temp)])) == 0) + + + + + + + + +class IfcUShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + +class IfcUShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcUnitAssignment_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcUnitAssignment" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + units = self.Units + + assert IfcCorrectUnitAssignment(units) + + + + + +class IfcUnitaryControlElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryControlElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcunitarycontrolelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryControlElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcUnitaryEquipment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryEquipment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcunitaryequipmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryEquipmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcValve_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcValve_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcvalvetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcValveType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValveType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVector_MagGreaterOrEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcVector" + RULE_NAME = "MagGreaterOrEqualZero" + + @staticmethod + def __call__(self): + magnitude = self.Magnitude + + assert magnitude >= 0.0 + + + + +def calc_IfcVector_Dim(self): + orientation = self.Orientation + return \ + orientation.Dim + + + + + + + + + + + + + +class IfcVibrationIsolator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationIsolator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcvibrationisolatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationIsolatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcVoidingFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcVoidingFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVoidingFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWallElementedCase_HasDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcWallElementedCase" + RULE_NAME = "HasDecomposition" + + @staticmethod + def __call__(self): + + + assert hiindex(self.IsDecomposedBy) > 0 + + + + + +class IfcWallStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcWallStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4.ifcrelassociates.relatedobjects') if ('ifc4.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWasteTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWasteTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcwasteterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWasteTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWindow_CorrectStyleAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectStyleAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4.ifcwindowtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWindowLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcWindowLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + firsttransomoffset = self.FirstTransomOffset + secondtransomoffset = self.SecondTransomOffset + + assert not (not exists(firsttransomoffset)) and exists(secondtransomoffset) + + + + +class IfcWindowLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + firstmullionoffset = self.FirstMullionOffset + secondmullionoffset = self.SecondMullionOffset + + assert not (not exists(firstmullionoffset)) and exists(secondmullionoffset) + + + + +class IfcWindowLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcWindowPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + + + + + + + +class IfcWindowType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWindowTypeEnum.USERDEFINED) or ((predefinedtype == IfcWindowTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWorkCalendar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkCalendar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkCalendarTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkCalendarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcWorkPlan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkPlan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkPlanTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkPlanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcWorkSchedule_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkSchedule" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkScheduleTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkScheduleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcZShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcZShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + + +class IfcZone_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcZone" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof(self.IsGroupedBy) == 0) or ((sizeof([temp for temp in self.IsGroupedBy[1 - 1].RelatedObjects if not ('ifc4.ifczone' in typeof(temp)) or ('ifc4.ifcspace' in typeof(temp)) or ('ifc4.ifcspatialzone' in typeof(temp))])) == 0) + + + + + +class IfcRepresentationContextSameWCS: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcGeometricRepresentationContext = file.by_type("IfcGeometricRepresentationContext") + isdifferent = False + if sizeof(IfcGeometricRepresentationContext) > 1: + for i in range(2, hiindex(IfcGeometricRepresentationContext) + 1): + if (IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem) != (IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem): + isdifferent = (not IfcSameValidPrecision(IfcGeometricRepresentationContext[1 - 1].Precision,IfcGeometricRepresentationContext[i - 1].Precision)) or (not IfcSameAxis2Placement(IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[1 - 1].Precision)) + if isdifferent == True: + break + + assert isdifferent == False + + + + + +class IfcSingleProjectInstance: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcProject = file.by_type("IfcProject") + + + + assert sizeof(IfcProject) <= 1 + + + + +def IfcAssociatedSurface(arg): + + surf = arg.BasisSurface + return surf + + +def IfcBaseAxis(dim, axis1, axis2, axis3): + + + + if dim == 3: + d1 = nvl(IfcNormalise(axis3),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,axis1) + u = [d2,IfcSecondProjAxis(d1,d2,axis2),d1] + else: + if exists(axis1): + d1 = IfcNormalise(axis1) + u = [d1,IfcOrthogonalComplement(d1)] + if exists(axis2): + factor = IfcDotProduct(axis2,u[2 - 1]) + if factor < 0.0: + u[2 - 1].DirectionRatios[1 - 1] = -u[2 - 1].DirectionRatios[1 - 1] + u[2 - 1].DirectionRatios[2 - 1] = -u[2 - 1].DirectionRatios[2 - 1] + else: + if exists(axis2): + d1 = IfcNormalise(axis2) + u = [IfcOrthogonalComplement(d1),d1] + u[1 - 1].DirectionRatios[1 - 1] = -u[1 - 1].DirectionRatios[1 - 1] + u[1 - 1].DirectionRatios[2 - 1] = -u[1 - 1].DirectionRatios[2 - 1] + else: + u = [IfcDirection(DirectionRatios=[1.0,0.0]),IfcDirection(DirectionRatios=[0.0,1.0])] + return u + + +def IfcBooleanChoose(b, choice1, choice2): + + if b: + return choice1 + else: + return choice2 + + +def IfcBuild2Axes(refdirection): + d = nvl(IfcNormalise(refdirection),IfcDirection(DirectionRatios=[1.0,0.0])) + return [d,IfcOrthogonalComplement(d)] + + +def IfcBuildAxes(axis, refdirection): + + d1 = nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,refdirection) + return [d2,IfcNormalise(IfcCrossProduct(d1,d2)).Orientation,d1] + + +def IfcConsecutiveSegments(segments): + result = True + for i in range(1, hiindex(segments) - 1 + 1): + if (segments[i - 1][hiindex(segments[i - 1]) - 1]) != (segments[i - 1][1 - 1]): + result = False + break + return result + + +def IfcConstraintsParamBSpline(degree, upknots, upcp, knotmult, knots): + result = True + + sum = knotmult[1 - 1] + for i in range(2, upknots + 1): + sum = sum + (knotmult[i - 1]) + if (degree < 1) or (upknots < 2) or (upcp < degree) or (sum != (degree + upcp + 2)): + result = False + return result + k = knotmult[1 - 1] + if (k < 1) or (k > (degree + 1)): + result = False + return result + for i in range(2, upknots + 1): + if ((knotmult[i - 1]) < 1) or ((knots[i - 1]) <= (knots[i - 1])): + result = False + return result + k = knotmult[i - 1] + if (i < upknots) and (k > degree): + result = False + return result + if (i == upknots) and (k > (degree + 1)): + result = False + return result + return result + + +def IfcConvertDirectionInto2D(direction): + direction2d = IfcDirection(DirectionRatios=[0.,1.]) + temp = list(direction2d.DirectionRatios) + temp[1 - 1] = direction.DirectionRatios[1 - 1] + direction2d.DirectionRatios = temp + temp = list(direction2d.DirectionRatios) + temp[2 - 1] = direction.DirectionRatios[2 - 1] + direction2d.DirectionRatios = temp + return direction2d + + +def IfcCorrectDimensions(m, dim): + + if m == lengthunit: + if dim == IfcDimensionalExponents(1,0,0,0,0,0,0): + return True + else: + return False + elif m == massunit: + if dim == IfcDimensionalExponents(0,1,0,0,0,0,0): + return True + else: + return False + elif m == timeunit: + if dim == IfcDimensionalExponents(0,0,1,0,0,0,0): + return True + else: + return False + elif m == electriccurrentunit: + if dim == IfcDimensionalExponents(0,0,0,1,0,0,0): + return True + else: + return False + elif m == thermodynamictemperatureunit: + if dim == IfcDimensionalExponents(0,0,0,0,1,0,0): + return True + else: + return False + elif m == amountofsubstanceunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,1,0): + return True + else: + return False + elif m == luminousintensityunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == planeangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == solidangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == areaunit: + if dim == IfcDimensionalExponents(2,0,0,0,0,0,0): + return True + else: + return False + elif m == volumeunit: + if dim == IfcDimensionalExponents(3,0,0,0,0,0,0): + return True + else: + return False + elif m == absorbeddoseunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == radioactivityunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == electriccapacitanceunit: + if dim == IfcDimensionalExponents(-2,-1,4,2,0,0,0): + return True + else: + return False + elif m == doseequivalentunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == electricchargeunit: + if dim == IfcDimensionalExponents(0,0,1,1,0,0,0): + return True + else: + return False + elif m == electricconductanceunit: + if dim == IfcDimensionalExponents(-2,-1,3,2,0,0,0): + return True + else: + return False + elif m == electricvoltageunit: + if dim == IfcDimensionalExponents(2,1,-3,-1,0,0,0): + return True + else: + return False + elif m == electricresistanceunit: + if dim == IfcDimensionalExponents(2,1,-3,-2,0,0,0): + return True + else: + return False + elif m == energyunit: + if dim == IfcDimensionalExponents(2,1,-2,0,0,0,0): + return True + else: + return False + elif m == forceunit: + if dim == IfcDimensionalExponents(1,1,-2,0,0,0,0): + return True + else: + return False + elif m == frequencyunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == inductanceunit: + if dim == IfcDimensionalExponents(2,1,-2,-2,0,0,0): + return True + else: + return False + elif m == illuminanceunit: + if dim == IfcDimensionalExponents(-2,0,0,0,0,0,1): + return True + else: + return False + elif m == luminousfluxunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == magneticfluxunit: + if dim == IfcDimensionalExponents(2,1,-2,-1,0,0,0): + return True + else: + return False + elif m == magneticfluxdensityunit: + if dim == IfcDimensionalExponents(0,1,-2,-1,0,0,0): + return True + else: + return False + elif m == powerunit: + if dim == IfcDimensionalExponents(2,1,-3,0,0,0,0): + return True + else: + return False + elif m == pressureunit: + if dim == IfcDimensionalExponents(-1,1,-2,0,0,0,0): + return True + else: + return False + else: + return unknown + + +def IfcCorrectFillAreaStyle(styles): + hatching = 0 + tiles = 0 + colour = 0 + external = 0 + external = sizeof([style for style in styles if 'ifc4.ifcexternallydefinedhatchstyle' in typeof(style)]) + hatching = sizeof([style for style in styles if 'ifc4.ifcfillareastylehatching' in typeof(style)]) + tiles = sizeof([style for style in styles if 'ifc4.ifcfillareastyletiles' in typeof(style)]) + colour = sizeof([style for style in styles if 'ifc4.ifccolour' in typeof(style)]) + if external > 1: + return False + if (external == 1) and ((hatching > 0) or (tiles > 0) or (colour > 0)): + return False + if colour > 1: + return False + if (hatching > 0) and (tiles > 0): + return False + return True + + +def IfcCorrectLocalPlacement(axisplacement, relplacement): + + if exists(relplacement): + if 'ifc4.ifcgridplacement' in typeof(relplacement): + return None + if 'ifc4.ifclocalplacement' in typeof(relplacement): + if 'ifc4.ifcaxis2placement2d' in typeof(axisplacement): + return True + if 'ifc4.ifcaxis2placement3d' in typeof(axisplacement): + if relplacement.RelativePlacement.Dim == 3: + return True + else: + return False + return True + return None + + +def IfcCorrectObjectAssignment(constraint, objects): + count = 0 + if not exists(constraint): + return True + if constraint == IfcObjectTypeEnum.NOTDEFINED: + return True + elif constraint == IfcObjectTypeEnum.PRODUCT: + count = sizeof([temp for temp in objects if not 'ifc4.ifcproduct' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROCESS: + count = sizeof([temp for temp in objects if not 'ifc4.ifcprocess' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.CONTROL: + count = sizeof([temp for temp in objects if not 'ifc4.ifccontrol' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.RESOURCE: + count = sizeof([temp for temp in objects if not 'ifc4.ifcresource' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.ACTOR: + count = sizeof([temp for temp in objects if not 'ifc4.ifcactor' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.GROUP: + count = sizeof([temp for temp in objects if not 'ifc4.ifcgroup' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROJECT: + count = sizeof([temp for temp in objects if not 'ifc4.ifcproject' in typeof(temp)]) + return count == 0 + else: + return None + + +def IfcCorrectUnitAssignment(units): + namedunitnumber = 0 + derivedunitnumber = 0 + monetaryunitnumber = 0 + namedunitnames = express_set([]) + derivedunitnames = express_set([]) + namedunitnumber = sizeof([temp for temp in units if ('ifc4.ifcnamedunit' in typeof(temp)) and (not temp.UnitType == IfcUnitEnum.USERDEFINED)]) + derivedunitnumber = sizeof([temp for temp in units if ('ifc4.ifcderivedunit' in typeof(temp)) and (not temp.UnitType == IfcDerivedUnitEnum.USERDEFINED)]) + monetaryunitnumber = sizeof([temp for temp in units if 'ifc4.ifcmonetaryunit' in typeof(temp)]) + for i in range(1, sizeof(units) + 1): + if ('ifc4.ifcnamedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcUnitEnum.USERDEFINED): + namedunitnames = namedunitnames + (units[i - 1].UnitType) + if ('ifc4.ifcderivedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcDerivedUnitEnum.USERDEFINED): + derivedunitnames = derivedunitnames + (units[i - 1].UnitType) + return (sizeof(namedunitnames) == namedunitnumber) and (sizeof(derivedunitnames) == derivedunitnumber) and (monetaryunitnumber <= 1) + + +def IfcCrossProduct(arg1, arg2): + + + + + if ((not exists(arg1)) or (arg1.Dim == 2)) or ((not exists(arg2)) or (arg2.Dim == 2)): + return None + else: + v1 = IfcNormalise(arg1).DirectionRatios + v2 = IfcNormalise(arg2).DirectionRatios + res = IfcDirection(DirectionRatios=[((v1[2 - 1]) * (v2[3 - 1])) - ((v1[3 - 1]) * (v2[2 - 1])),((v1[3 - 1]) * (v2[1 - 1])) - ((v1[1 - 1]) * (v2[3 - 1])),((v1[1 - 1]) * (v2[2 - 1])) - ((v1[2 - 1]) * (v2[1 - 1]))]) + mag = 0.0 + for i in range(1, 3 + 1): + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=arg1, Magnitude=0.0) + return result + + +def IfcCurveDim(curve): + + if 'ifc4.ifcline' in typeof(curve): + return curve.Pnt.Dim + if 'ifc4.ifcconic' in typeof(curve): + return curve.Position.Dim + if 'ifc4.ifcpolyline' in typeof(curve): + return curve.Points[1 - 1].Dim + if 'ifc4.ifctrimmedcurve' in typeof(curve): + return IfcCurveDim(curve.BasisCurve) + if 'ifc4.ifccompositecurve' in typeof(curve): + return curve.Segments[1 - 1].Dim + if 'ifc4.ifcbsplinecurve' in typeof(curve): + return curve.ControlPointsList[1 - 1].Dim + if 'ifc4.ifcoffsetcurve2d' in typeof(curve): + return 2 + if 'ifc4.ifcoffsetcurve3d' in typeof(curve): + return 3 + if 'ifc4.ifcpcurve' in typeof(curve): + return 3 + if 'ifc4.ifcindexedpolycurve' in typeof(curve): + return curve.Points.Dim + return None + + +def IfcCurveWeightsPositive(b): + result = True + for i in range(0, b.UpperIndexOnControlPoints + 1): + if (b.Weights[i - 1]) <= 0.0: + result = False + return result + return result + + +def IfcDeriveDimensionalExponents(unitelements): + result = IfcDimensionalExponents(0,0,0,0,0,0,0) + for i in range(loindex(unitelements), hiindex(unitelements) + 1): + result.LengthExponent = result.LengthExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LengthExponent)) + result.MassExponent = result.MassExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.MassExponent)) + result.TimeExponent = result.TimeExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.TimeExponent)) + result.ElectricCurrentExponent = result.ElectricCurrentExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ElectricCurrentExponent)) + result.ThermodynamicTemperatureExponent = result.ThermodynamicTemperatureExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ThermodynamicTemperatureExponent)) + result.AmountOfSubstanceExponent = result.AmountOfSubstanceExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.AmountOfSubstanceExponent)) + result.LuminousIntensityExponent = result.LuminousIntensityExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LuminousIntensityExponent)) + return result + + +def IfcDimensionsForSiUnit(n): + + if n == metre: + return IfcDimensionalExponents(1,0,0,0,0,0,0) + elif n == square_metre: + return IfcDimensionalExponents(2,0,0,0,0,0,0) + elif n == cubic_metre: + return IfcDimensionalExponents(3,0,0,0,0,0,0) + elif n == gram: + return IfcDimensionalExponents(0,1,0,0,0,0,0) + elif n == second: + return IfcDimensionalExponents(0,0,1,0,0,0,0) + elif n == ampere: + return IfcDimensionalExponents(0,0,0,1,0,0,0) + elif n == kelvin: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == mole: + return IfcDimensionalExponents(0,0,0,0,0,1,0) + elif n == candela: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == radian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == steradian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == hertz: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == newton: + return IfcDimensionalExponents(1,1,-2,0,0,0,0) + elif n == pascal: + return IfcDimensionalExponents(-1,1,-2,0,0,0,0) + elif n == joule: + return IfcDimensionalExponents(2,1,-2,0,0,0,0) + elif n == watt: + return IfcDimensionalExponents(2,1,-3,0,0,0,0) + elif n == coulomb: + return IfcDimensionalExponents(0,0,1,1,0,0,0) + elif n == volt: + return IfcDimensionalExponents(2,1,-3,-1,0,0,0) + elif n == farad: + return IfcDimensionalExponents(-2,-1,4,2,0,0,0) + elif n == ohm: + return IfcDimensionalExponents(2,1,-3,-2,0,0,0) + elif n == siemens: + return IfcDimensionalExponents(-2,-1,3,2,0,0,0) + elif n == weber: + return IfcDimensionalExponents(2,1,-2,-1,0,0,0) + elif n == tesla: + return IfcDimensionalExponents(0,1,-2,-1,0,0,0) + elif n == henry: + return IfcDimensionalExponents(2,1,-2,-2,0,0,0) + elif n == degree_celsius: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == lumen: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == lux: + return IfcDimensionalExponents(-2,0,0,0,0,0,1) + elif n == becquerel: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == gray: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + elif n == sievert: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + else: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + + +def IfcDotProduct(arg1, arg2): + + + + if (not exists(arg1)) or (not exists(arg2)): + scalar = None + else: + if arg1.Dim != arg2.Dim: + scalar = None + else: + vec1 = IfcNormalise(arg1) + vec2 = IfcNormalise(arg2) + ndim = arg1.Dim + scalar = 0.0 + for i in range(1, ndim + 1): + scalar = scalar + ((vec1.DirectionRatios[i - 1]) * (vec2.DirectionRatios[i - 1])) + return scalar + + +def IfcFirstProjAxis(zaxis, arg): + + + + + if not exists(zaxis): + return None + else: + z = IfcNormalise(zaxis) + if not exists(arg): + if z.DirectionRatios != [1.0,0.0,0.0]: + v = IfcDirection(DirectionRatios=[1.0,0.0,0.0]) + else: + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + if arg.Dim != 3: + return None + if IfcCrossProduct(arg,z).Magnitude == 0.0: + return None + else: + v = IfcNormalise(arg) + xvec = IfcScalarTimesVector(IfcDotProduct(v,z),z) + xaxis = IfcVectorDifference(v,xvec).Orientation + xaxis = IfcNormalise(xaxis) + return xaxis + + +def IfcGetBasisSurface(c): + + + surfs = [] + if 'ifc4.ifcpcurve' in typeof(c): + surfs = [c.BasisSurface] + else: + if 'ifc4.ifcsurfacecurve' in typeof(c): + n = sizeof(c.AssociatedGeometry) + for i in range(1, n + 1): + surfs = surfs + (IfcAssociatedSurface(c.AssociatedGeometry[i - 1])) + if 'ifc4.ifccompositecurveonsurface' in typeof(c): + n = sizeof(c.Segments) + surfs = IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve) + if n > 1: + for i in range(2, n + 1): + surfs = surfs * (IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve)) + return surfs + + +def IfcListToArray(lis, low, u): + + + n = sizeof(lis) + if n != (u - low + 1): + return None + else: + res = ([lis[1 - 1]] * n) + for i in range(2, n + 1): + temp = list(res) + temp[low - 1] = lis[i - 1] + res = temp + return res + + +def IfcLoopHeadToTail(aloop): + + p = True + n = sizeof(aloop.EdgeList) + for i in range(2, n + 1): + p = p and ((aloop.EdgeList[i - 1].EdgeEnd) == (aloop.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcMakeArrayOfArray(lis, low1, u1, low2, u2): + + if (u1 - low1 + 1) != sizeof(lis): + return None + if (u2 - low2 + 1) != (sizeof(lis[1 - 1])): + return None + res = ([IfcListToArray(lis[1 - 1],low2,u2)] * u1 - low1 + 1) + for i in range(2, hiindex(lis) + 1): + if (u2 - low2 + 1) != (sizeof(lis[i - 1])): + return None + temp = list(res) + temp[low1 - 1] = IfcListToArray(lis[i - 1],low2,u2) + res = temp + return res + + +def IfcMlsTotalThickness(layerset): + max = layerset.MaterialLayers[1 - 1].LayerThickness + if sizeof(layerset.MaterialLayers) > 1: + for i in range(2, hiindex(layerset.MaterialLayers) + 1): + max = max + (layerset.MaterialLayers[i - 1].LayerThickness) + return max + + +def IfcNormalise(arg): + + v = IfcDirection(DirectionRatios=[1.,0.]) + vec = IfcVector(Orientation=IfcDirection(DirectionRatios=[1.,0.]), Magnitude=1.) + + result = v + if not exists(arg): + return None + else: + if 'ifc4.ifcvector' in typeof(arg): + ndim = arg.Dim + v.DirectionRatios = arg.Orientation.DirectionRatios + vec.Magnitude = arg.Magnitude + vec.Orientation = v + if arg.Magnitude == 0.0: + return None + else: + vec.Magnitude = 1.0 + else: + ndim = arg.Dim + v.DirectionRatios = arg.DirectionRatios + mag = 0.0 + for i in range(1, ndim + 1): + mag = mag + ((v.DirectionRatios[i - 1]) * (v.DirectionRatios[i - 1])) + if mag > 0.0: + mag = sqrt(mag) + for i in range(1, ndim + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = (v.DirectionRatios[i - 1]) / mag + v.DirectionRatios = temp + if 'ifc4.ifcvector' in typeof(arg): + vec.Orientation = v + result = vec + else: + result = v + else: + return None + return result + + +def IfcOrthogonalComplement(vec): + + if (not exists(vec)) or (vec.Dim != 2): + return None + else: + result = IfcDirection(DirectionRatios=[-vec.DirectionRatios[2 - 1],vec.DirectionRatios[1 - 1]]) + return result + + +def IfcPathHeadToTail(apath): + n = 0 + p = unknown + n = sizeof(apath.EdgeList) + for i in range(2, n + 1): + p = p and ((apath.EdgeList[i - 1].EdgeEnd) == (apath.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcPointListDim(pointlist): + + if 'ifc4.ifccartesianpointlist2d' in typeof(pointlist): + return 2 + if 'ifc4.ifccartesianpointlist3d' in typeof(pointlist): + return 3 + return None + + +def IfcSameAxis2Placement(ap1, ap2, epsilon): + + return (IfcSameDirection(ap1.P[1 - 1],ap2.P[1 - 1],epsilon)) and (IfcSameDirection(ap1.P[2 - 1],ap2.P[2 - 1],epsilon)) and IfcSameCartesianPoint(ap1.Location,ap1.Location,epsilon) + + +def IfcSameCartesianPoint(cp1, cp2, epsilon): + cp1x = cp1.Coordinates[1 - 1] + cp1y = cp1.Coordinates[2 - 1] + cp1z = 0 + cp2x = cp2.Coordinates[1 - 1] + cp2y = cp2.Coordinates[2 - 1] + cp2z = 0 + if sizeof(cp1.Coordinates) > 2: + cp1z = cp1.Coordinates[3 - 1] + if sizeof(cp2.Coordinates) > 2: + cp2z = cp2.Coordinates[3 - 1] + return IfcSameValue(cp1x,cp2x,epsilon) and IfcSameValue(cp1y,cp2y,epsilon) and IfcSameValue(cp1z,cp2z,epsilon) + + +def IfcSameDirection(dir1, dir2, epsilon): + dir1x = dir1.DirectionRatios[1 - 1] + dir1y = dir1.DirectionRatios[2 - 1] + dir1z = 0 + dir2x = dir2.DirectionRatios[1 - 1] + dir2y = dir2.DirectionRatios[2 - 1] + dir2z = 0 + if sizeof(dir1.DirectionRatios) > 2: + dir1z = dir1.DirectionRatios[3 - 1] + if sizeof(dir2.DirectionRatios) > 2: + dir2z = dir2.DirectionRatios[3 - 1] + return IfcSameValue(dir1x,dir2x,epsilon) and IfcSameValue(dir1y,dir2y,epsilon) and IfcSameValue(dir1z,dir2z,epsilon) + + +def IfcSameValidPrecision(epsilon1, epsilon2): + + defaulteps = 0.000001 + derivationofeps = 1.001 + uppereps = 1.0 + valideps1 = nvl(epsilon1,defaulteps) + valideps2 = nvl(epsilon2,defaulteps) + return (0.0 < valideps1) and (valideps1 <= (derivationofeps * valideps2)) and (valideps2 <= (derivationofeps * valideps1)) and (valideps2 < uppereps) + + +def IfcSameValue(value1, value2, epsilon): + + defaulteps = 0.000001 + valideps = nvl(epsilon,defaulteps) + return ((value1 + valideps) > value2) and (value1 < (value2 + valideps)) + + +def IfcScalarTimesVector(scalar, vec): + + + + if (not exists(scalar)) or (not exists(vec)): + return None + else: + if 'ifc4.ifcvector' in typeof(vec): + v = vec.Orientation + mag = scalar * vec.Magnitude + else: + v = vec + mag = scalar + if mag < 0.0: + for i in range(1, sizeof(v.DirectionRatios) + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = -v.DirectionRatios[i - 1] + v.DirectionRatios = temp + mag = -mag + result = IfcVector(Orientation=IfcNormalise(v), Magnitude=mag) + return result + + +def IfcSecondProjAxis(zaxis, xaxis, arg): + + + + if not exists(arg): + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + v = arg + temp = IfcScalarTimesVector(IfcDotProduct(v,zaxis),zaxis) + yaxis = IfcVectorDifference(v,temp) + temp = IfcScalarTimesVector(IfcDotProduct(v,xaxis),xaxis) + yaxis = IfcVectorDifference(yaxis,temp) + yaxis = IfcNormalise(yaxis) + return yaxis.Orientation + + +def IfcShapeRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'point': + count = sizeof([temp for temp in items if 'ifc4.ifcpoint' in typeof(temp)]) + elif reptype.lower() == 'pointcloud': + count = sizeof([temp for temp in items if 'ifc4.ifccartesianpointlist3d' in typeof(temp)]) + elif reptype.lower() == 'curve': + count = sizeof([temp for temp in items if 'ifc4.ifccurve' in typeof(temp)]) + elif reptype.lower() == 'curve2d': + count = sizeof([temp for temp in items if ('ifc4.ifccurve' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'curve3d': + count = sizeof([temp for temp in items if ('ifc4.ifccurve' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'surface': + count = sizeof([temp for temp in items if 'ifc4.ifcsurface' in typeof(temp)]) + elif reptype.lower() == 'surface2d': + count = sizeof([temp for temp in items if ('ifc4.ifcsurface' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'surface3d': + count = sizeof([temp for temp in items if ('ifc4.ifcsurface' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'fillarea': + count = sizeof([temp for temp in items if 'ifc4.ifcannotationfillarea' in typeof(temp)]) + elif reptype.lower() == 'text': + count = sizeof([temp for temp in items if 'ifc4.ifctextliteral' in typeof(temp)]) + elif reptype.lower() == 'advancedsurface': + count = sizeof([temp for temp in items if 'ifc4.ifcbsplinesurface' in typeof(temp)]) + elif reptype.lower() == 'annotation2d': + count = sizeof([temp for temp in items if (sizeof(typeof(temp) * ['ifc4.ifcpoint','ifc4.ifccurve','ifc4.ifcgeometriccurveset','ifc4.ifcannotationfillarea','ifc4.ifctextliteral'])) == 1]) + elif reptype.lower() == 'geometricset': + count = sizeof([temp for temp in items if ('ifc4.ifcgeometricset' in typeof(temp)) or ('ifc4.ifcpoint' in typeof(temp)) or ('ifc4.ifccurve' in typeof(temp)) or ('ifc4.ifcsurface' in typeof(temp))]) + elif reptype.lower() == 'geometriccurveset': + count = sizeof([temp for temp in items if ('ifc4.ifcgeometriccurveset' in typeof(temp)) or ('ifc4.ifcgeometricset' in typeof(temp)) or ('ifc4.ifcpoint' in typeof(temp)) or ('ifc4.ifccurve' in typeof(temp))]) + for i in range(1, hiindex(items) + 1): + if 'ifc4.ifcgeometricset' in (typeof(items[i - 1])): + if (sizeof([temp for temp in items[i - 1].Elements if 'ifc4.ifcsurface' in typeof(temp)])) > 0: + count = count - 1 + elif reptype.lower() == 'tessellation': + count = sizeof([temp for temp in items if 'ifc4.ifctessellateditem' in typeof(temp)]) + elif reptype.lower() == 'surfaceorsolidmodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4.ifctessellateditem','ifc4.ifcshellbasedsurfacemodel','ifc4.ifcfacebasedsurfacemodel','ifc4.ifcsolidmodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'surfacemodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4.ifctessellateditem','ifc4.ifcshellbasedsurfacemodel','ifc4.ifcfacebasedsurfacemodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'solidmodel': + count = sizeof([temp for temp in items if 'ifc4.ifcsolidmodel' in typeof(temp)]) + elif reptype.lower() == 'sweptsolid': + count = sizeof([temp for temp in items if ((sizeof(['ifc4.ifcextrudedareasolid','ifc4.ifcrevolvedareasolid'] * typeof(temp))) >= 1) and ((sizeof(['ifc4.ifcextrudedareasolidtapered','ifc4.ifcrevolvedareasolidtapered'] * typeof(temp))) == 0)]) + elif reptype.lower() == 'advancedsweptsolid': + count = sizeof([temp for temp in items if (sizeof(['ifc4.ifcsweptareasolid','ifc4.ifcsweptdisksolid'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'csg': + count = sizeof([temp for temp in items if (sizeof(['ifc4.ifcbooleanresult','ifc4.ifccsgprimitive3d','ifc4.ifccsgsolid'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'clipping': + count = sizeof([temp for temp in items if (sizeof(['ifc4.ifccsgsolid','ifc4.ifcbooleanclippingresult'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'brep': + count = sizeof([temp for temp in items if 'ifc4.ifcfacetedbrep' in typeof(temp)]) + elif reptype.lower() == 'advancedbrep': + count = sizeof([temp for temp in items if 'ifc4.ifcmanifoldsolidbrep' in typeof(temp)]) + elif reptype.lower() == 'boundingbox': + count = sizeof([temp for temp in items if 'ifc4.ifcboundingbox' in typeof(temp)]) + if sizeof(items) > 1: + count = 0 + elif reptype.lower() == 'sectionedspine': + count = sizeof([temp for temp in items if 'ifc4.ifcsectionedspine' in typeof(temp)]) + elif reptype.lower() == 'lightsource': + count = sizeof([temp for temp in items if 'ifc4.ifclightsource' in typeof(temp)]) + elif reptype.lower() == 'mappedrepresentation': + count = sizeof([temp for temp in items if 'ifc4.ifcmappeditem' in typeof(temp)]) + else: + return None + return count == sizeof(items) + + +def IfcSurfaceWeightsPositive(b): + result = True + weights = b.Weights + for i in range(0, b.UUpper + 1): + for j in range(0, b.VUpper + 1): + if (weights[i - 1][j - 1]) <= 0.0: + result = False + return result + return result + + +def IfcTaperedSweptAreaProfiles(startarea, endarea): + result = False + if 'ifc4.ifcparameterizedprofiledef' in typeof(startarea): + if 'ifc4.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = typeof(startarea) == typeof(endarea) + else: + if 'ifc4.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = False + return result + + +def IfcTopologyRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'vertex': + count = sizeof([temp for temp in items if 'ifc4.ifcvertex' in typeof(temp)]) + elif reptype.lower() == 'edge': + count = sizeof([temp for temp in items if 'ifc4.ifcedge' in typeof(temp)]) + elif reptype.lower() == 'path': + count = sizeof([temp for temp in items if 'ifc4.ifcpath' in typeof(temp)]) + elif reptype.lower() == 'face': + count = sizeof([temp for temp in items if 'ifc4.ifcface' in typeof(temp)]) + elif reptype.lower() == 'shell': + count = sizeof([temp for temp in items if ('ifc4.ifcopenshell' in typeof(temp)) or ('ifc4.ifcclosedshell' in typeof(temp))]) + elif reptype.lower() == 'undefined': + return True + else: + return None + return count == sizeof(items) + + +def IfcUniqueDefinitionNames(relations): + + + properties = express_set([]) + + if sizeof(relations) == 0: + return True + for i in range(1, hiindex(relations) + 1): + definition = relations[i - 1].RelatingPropertyDefinition + if 'ifc4.ifcpropertysetdefinition' in typeof(definition): + properties = properties + definition + else: + if 'ifc4.ifcpropertysetdefinitionset' in typeof(definition): + definitionset = definition + for j in range(1, hiindex(definitionset) + 1): + properties = properties + (definitionset[j - 1]) + result = IfcUniquePropertySetNames(properties) + return result + + +def IfcUniquePropertyName(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniquePropertySetNames(properties): + names = express_set([]) + unnamed = 0 + for i in range(1, hiindex(properties) + 1): + if 'ifc4.ifcpropertyset' in (typeof(properties[i - 1])): + names = names + (properties[i - 1].Name) + else: + unnamed = unnamed + 1 + return (sizeof(names) + unnamed) == sizeof(properties) + + +def IfcUniquePropertyTemplateNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniqueQuantityNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcVectorDifference(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) - (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + +def IfcVectorSum(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) + (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + diff --git a/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X1.py b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X1.py new file mode 100644 index 0000000000..e12dc26767 --- /dev/null +++ b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X1.py @@ -0,0 +1,21850 @@ +import ifcopenshell + +def exists(v): + if callable(v): + try: return v() is not None + except IndexError as e: return False + else: return v is not None + + + +def nvl(v, default): return v if v is not None else default + + +sizeof = len +hiindex = len +blength = len +loindex = lambda x: 1 +from math import * +unknown = 'UNKNOWN' + +def usedin(inst, ref_name): + if inst is None: + return [] + _, __, attr = ref_name.split('.') + def filter(): + for ref, attr_idx in inst.wrapped_data.file.get_inverse(inst, allow_duplicate=True, with_attribute_indices=True): + if ref.wrapped_data.get_attribute_names()[attr_idx].lower() == attr: + yield ref + return list(filter()) + + +class express_set(set): + def __rmul__(self, other): + return express_set(set(other) & self) + def __add__(self, other): + def make_list(v): + # Comply with 12.6.3 Union operator + if isinstance(v, (list, tuple, set, express_set)): + return list(v) + else: + return [v] + return express_set(list(self) + make_list(other)) + __radd__ = __add__ + def __repr__(self): + return repr(set(self)) + + +def typeof(inst): + if not inst: + # If V evaluates to indeterminate (?), an empty set is returned. + return express_set([]) + schema_name = inst.is_a(True).split('.')[0].lower() + def inner(): + decl = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(inst.is_a()) + while decl: + yield '.'.join((schema_name, decl.name().lower())) + decl = decl.supertype() + return express_set(inner()) + +class enum_namespace: + def __getattr__(self, k): + return k.upper() + + +IfcActionRequestTypeEnum = enum_namespace() + + +email = IfcActionRequestTypeEnum.EMAIL + + +fax = IfcActionRequestTypeEnum.FAX + + +phone = IfcActionRequestTypeEnum.PHONE + + +post = IfcActionRequestTypeEnum.POST + + +verbal = IfcActionRequestTypeEnum.VERBAL + + +userdefined = IfcActionRequestTypeEnum.USERDEFINED + + +notdefined = IfcActionRequestTypeEnum.NOTDEFINED + + +IfcActionSourceTypeEnum = enum_namespace() + + +dead_load_g = IfcActionSourceTypeEnum.DEAD_LOAD_G + + +completion_g1 = IfcActionSourceTypeEnum.COMPLETION_G1 + + +live_load_q = IfcActionSourceTypeEnum.LIVE_LOAD_Q + + +snow_s = IfcActionSourceTypeEnum.SNOW_S + + +wind_w = IfcActionSourceTypeEnum.WIND_W + + +prestressing_p = IfcActionSourceTypeEnum.PRESTRESSING_P + + +settlement_u = IfcActionSourceTypeEnum.SETTLEMENT_U + + +temperature_t = IfcActionSourceTypeEnum.TEMPERATURE_T + + +earthquake_e = IfcActionSourceTypeEnum.EARTHQUAKE_E + + +fire = IfcActionSourceTypeEnum.FIRE + + +impulse = IfcActionSourceTypeEnum.IMPULSE + + +impact = IfcActionSourceTypeEnum.IMPACT + + +transport = IfcActionSourceTypeEnum.TRANSPORT + + +erection = IfcActionSourceTypeEnum.ERECTION + + +propping = IfcActionSourceTypeEnum.PROPPING + + +system_imperfection = IfcActionSourceTypeEnum.SYSTEM_IMPERFECTION + + +shrinkage = IfcActionSourceTypeEnum.SHRINKAGE + + +creep = IfcActionSourceTypeEnum.CREEP + + +lack_of_fit = IfcActionSourceTypeEnum.LACK_OF_FIT + + +buoyancy = IfcActionSourceTypeEnum.BUOYANCY + + +ice = IfcActionSourceTypeEnum.ICE + + +current = IfcActionSourceTypeEnum.CURRENT + + +wave = IfcActionSourceTypeEnum.WAVE + + +rain = IfcActionSourceTypeEnum.RAIN + + +brakes = IfcActionSourceTypeEnum.BRAKES + + +userdefined = IfcActionSourceTypeEnum.USERDEFINED + + +notdefined = IfcActionSourceTypeEnum.NOTDEFINED + + +IfcActionTypeEnum = enum_namespace() + + +permanent_g = IfcActionTypeEnum.PERMANENT_G + + +variable_q = IfcActionTypeEnum.VARIABLE_Q + + +extraordinary_a = IfcActionTypeEnum.EXTRAORDINARY_A + + +userdefined = IfcActionTypeEnum.USERDEFINED + + +notdefined = IfcActionTypeEnum.NOTDEFINED + + +IfcActuatorTypeEnum = enum_namespace() + + +electricactuator = IfcActuatorTypeEnum.ELECTRICACTUATOR + + +handoperatedactuator = IfcActuatorTypeEnum.HANDOPERATEDACTUATOR + + +hydraulicactuator = IfcActuatorTypeEnum.HYDRAULICACTUATOR + + +pneumaticactuator = IfcActuatorTypeEnum.PNEUMATICACTUATOR + + +thermostaticactuator = IfcActuatorTypeEnum.THERMOSTATICACTUATOR + + +userdefined = IfcActuatorTypeEnum.USERDEFINED + + +notdefined = IfcActuatorTypeEnum.NOTDEFINED + + +IfcAddressTypeEnum = enum_namespace() + + +office = IfcAddressTypeEnum.OFFICE + + +site = IfcAddressTypeEnum.SITE + + +home = IfcAddressTypeEnum.HOME + + +distributionpoint = IfcAddressTypeEnum.DISTRIBUTIONPOINT + + +userdefined = IfcAddressTypeEnum.USERDEFINED + + +IfcAirTerminalBoxTypeEnum = enum_namespace() + + +constantflow = IfcAirTerminalBoxTypeEnum.CONSTANTFLOW + + +variableflowpressuredependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREDEPENDANT + + +variableflowpressureindependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREINDEPENDANT + + +userdefined = IfcAirTerminalBoxTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalBoxTypeEnum.NOTDEFINED + + +IfcAirTerminalTypeEnum = enum_namespace() + + +diffuser = IfcAirTerminalTypeEnum.DIFFUSER + + +grille = IfcAirTerminalTypeEnum.GRILLE + + +louvre = IfcAirTerminalTypeEnum.LOUVRE + + +register = IfcAirTerminalTypeEnum.REGISTER + + +userdefined = IfcAirTerminalTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalTypeEnum.NOTDEFINED + + +IfcAirToAirHeatRecoveryTypeEnum = enum_namespace() + + +fixedplatecounterflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECOUNTERFLOWEXCHANGER + + +fixedplatecrossflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECROSSFLOWEXCHANGER + + +fixedplateparallelflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATEPARALLELFLOWEXCHANGER + + +rotarywheel = IfcAirToAirHeatRecoveryTypeEnum.ROTARYWHEEL + + +runaroundcoilloop = IfcAirToAirHeatRecoveryTypeEnum.RUNAROUNDCOILLOOP + + +heatpipe = IfcAirToAirHeatRecoveryTypeEnum.HEATPIPE + + +twintowerenthalpyrecoveryloops = IfcAirToAirHeatRecoveryTypeEnum.TWINTOWERENTHALPYRECOVERYLOOPS + + +thermosiphonsealedtubeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONSEALEDTUBEHEATEXCHANGERS + + +thermosiphoncoiltypeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONCOILTYPEHEATEXCHANGERS + + +userdefined = IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED + + +notdefined = IfcAirToAirHeatRecoveryTypeEnum.NOTDEFINED + + +IfcAlarmTypeEnum = enum_namespace() + + +bell = IfcAlarmTypeEnum.BELL + + +breakglassbutton = IfcAlarmTypeEnum.BREAKGLASSBUTTON + + +light = IfcAlarmTypeEnum.LIGHT + + +manualpullbox = IfcAlarmTypeEnum.MANUALPULLBOX + + +siren = IfcAlarmTypeEnum.SIREN + + +whistle = IfcAlarmTypeEnum.WHISTLE + + +userdefined = IfcAlarmTypeEnum.USERDEFINED + + +notdefined = IfcAlarmTypeEnum.NOTDEFINED + + +IfcAlignmentTypeEnum = enum_namespace() + + +userdefined = IfcAlignmentTypeEnum.USERDEFINED + + +notdefined = IfcAlignmentTypeEnum.NOTDEFINED + + +IfcAnalysisModelTypeEnum = enum_namespace() + + +in_plane_loading_2d = IfcAnalysisModelTypeEnum.IN_PLANE_LOADING_2D + + +out_plane_loading_2d = IfcAnalysisModelTypeEnum.OUT_PLANE_LOADING_2D + + +loading_3d = IfcAnalysisModelTypeEnum.LOADING_3D + + +userdefined = IfcAnalysisModelTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisModelTypeEnum.NOTDEFINED + + +IfcAnalysisTheoryTypeEnum = enum_namespace() + + +first_order_theory = IfcAnalysisTheoryTypeEnum.FIRST_ORDER_THEORY + + +second_order_theory = IfcAnalysisTheoryTypeEnum.SECOND_ORDER_THEORY + + +third_order_theory = IfcAnalysisTheoryTypeEnum.THIRD_ORDER_THEORY + + +full_nonlinear_theory = IfcAnalysisTheoryTypeEnum.FULL_NONLINEAR_THEORY + + +userdefined = IfcAnalysisTheoryTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisTheoryTypeEnum.NOTDEFINED + + +IfcArithmeticOperatorEnum = enum_namespace() + + +add = IfcArithmeticOperatorEnum.ADD + + +divide = IfcArithmeticOperatorEnum.DIVIDE + + +multiply = IfcArithmeticOperatorEnum.MULTIPLY + + +subtract = IfcArithmeticOperatorEnum.SUBTRACT + + +IfcAssemblyPlaceEnum = enum_namespace() + + +site = IfcAssemblyPlaceEnum.SITE + + +factory = IfcAssemblyPlaceEnum.FACTORY + + +notdefined = IfcAssemblyPlaceEnum.NOTDEFINED + + +IfcAudioVisualApplianceTypeEnum = enum_namespace() + + +amplifier = IfcAudioVisualApplianceTypeEnum.AMPLIFIER + + +camera = IfcAudioVisualApplianceTypeEnum.CAMERA + + +display = IfcAudioVisualApplianceTypeEnum.DISPLAY + + +microphone = IfcAudioVisualApplianceTypeEnum.MICROPHONE + + +player = IfcAudioVisualApplianceTypeEnum.PLAYER + + +projector = IfcAudioVisualApplianceTypeEnum.PROJECTOR + + +receiver = IfcAudioVisualApplianceTypeEnum.RECEIVER + + +speaker = IfcAudioVisualApplianceTypeEnum.SPEAKER + + +switcher = IfcAudioVisualApplianceTypeEnum.SWITCHER + + +telephone = IfcAudioVisualApplianceTypeEnum.TELEPHONE + + +tuner = IfcAudioVisualApplianceTypeEnum.TUNER + + +userdefined = IfcAudioVisualApplianceTypeEnum.USERDEFINED + + +notdefined = IfcAudioVisualApplianceTypeEnum.NOTDEFINED + + +IfcBSplineCurveForm = enum_namespace() + + +polyline_form = IfcBSplineCurveForm.POLYLINE_FORM + + +circular_arc = IfcBSplineCurveForm.CIRCULAR_ARC + + +elliptic_arc = IfcBSplineCurveForm.ELLIPTIC_ARC + + +parabolic_arc = IfcBSplineCurveForm.PARABOLIC_ARC + + +hyperbolic_arc = IfcBSplineCurveForm.HYPERBOLIC_ARC + + +unspecified = IfcBSplineCurveForm.UNSPECIFIED + + +IfcBSplineSurfaceForm = enum_namespace() + + +plane_surf = IfcBSplineSurfaceForm.PLANE_SURF + + +cylindrical_surf = IfcBSplineSurfaceForm.CYLINDRICAL_SURF + + +conical_surf = IfcBSplineSurfaceForm.CONICAL_SURF + + +spherical_surf = IfcBSplineSurfaceForm.SPHERICAL_SURF + + +toroidal_surf = IfcBSplineSurfaceForm.TOROIDAL_SURF + + +surf_of_revolution = IfcBSplineSurfaceForm.SURF_OF_REVOLUTION + + +ruled_surf = IfcBSplineSurfaceForm.RULED_SURF + + +generalised_cone = IfcBSplineSurfaceForm.GENERALISED_CONE + + +quadric_surf = IfcBSplineSurfaceForm.QUADRIC_SURF + + +surf_of_linear_extrusion = IfcBSplineSurfaceForm.SURF_OF_LINEAR_EXTRUSION + + +unspecified = IfcBSplineSurfaceForm.UNSPECIFIED + + +IfcBeamTypeEnum = enum_namespace() + + +beam = IfcBeamTypeEnum.BEAM + + +joist = IfcBeamTypeEnum.JOIST + + +hollowcore = IfcBeamTypeEnum.HOLLOWCORE + + +lintel = IfcBeamTypeEnum.LINTEL + + +spandrel = IfcBeamTypeEnum.SPANDREL + + +t_beam = IfcBeamTypeEnum.T_BEAM + + +userdefined = IfcBeamTypeEnum.USERDEFINED + + +notdefined = IfcBeamTypeEnum.NOTDEFINED + + +IfcBenchmarkEnum = enum_namespace() + + +greaterthan = IfcBenchmarkEnum.GREATERTHAN + + +greaterthanorequalto = IfcBenchmarkEnum.GREATERTHANOREQUALTO + + +lessthan = IfcBenchmarkEnum.LESSTHAN + + +lessthanorequalto = IfcBenchmarkEnum.LESSTHANOREQUALTO + + +equalto = IfcBenchmarkEnum.EQUALTO + + +notequalto = IfcBenchmarkEnum.NOTEQUALTO + + +includes = IfcBenchmarkEnum.INCLUDES + + +notincludes = IfcBenchmarkEnum.NOTINCLUDES + + +includedin = IfcBenchmarkEnum.INCLUDEDIN + + +notincludedin = IfcBenchmarkEnum.NOTINCLUDEDIN + + +IfcBoilerTypeEnum = enum_namespace() + + +water = IfcBoilerTypeEnum.WATER + + +steam = IfcBoilerTypeEnum.STEAM + + +userdefined = IfcBoilerTypeEnum.USERDEFINED + + +notdefined = IfcBoilerTypeEnum.NOTDEFINED + + +IfcBooleanOperator = enum_namespace() + + +union = IfcBooleanOperator.UNION + + +intersection = IfcBooleanOperator.INTERSECTION + + +difference = IfcBooleanOperator.DIFFERENCE + + +IfcBuildingElementPartTypeEnum = enum_namespace() + + +insulation = IfcBuildingElementPartTypeEnum.INSULATION + + +precastpanel = IfcBuildingElementPartTypeEnum.PRECASTPANEL + + +userdefined = IfcBuildingElementPartTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementPartTypeEnum.NOTDEFINED + + +IfcBuildingElementProxyTypeEnum = enum_namespace() + + +complex = IfcBuildingElementProxyTypeEnum.COMPLEX + + +element = IfcBuildingElementProxyTypeEnum.ELEMENT + + +partial = IfcBuildingElementProxyTypeEnum.PARTIAL + + +provisionforvoid = IfcBuildingElementProxyTypeEnum.PROVISIONFORVOID + + +provisionforspace = IfcBuildingElementProxyTypeEnum.PROVISIONFORSPACE + + +userdefined = IfcBuildingElementProxyTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementProxyTypeEnum.NOTDEFINED + + +IfcBuildingSystemTypeEnum = enum_namespace() + + +fenestration = IfcBuildingSystemTypeEnum.FENESTRATION + + +foundation = IfcBuildingSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuildingSystemTypeEnum.LOADBEARING + + +outershell = IfcBuildingSystemTypeEnum.OUTERSHELL + + +shading = IfcBuildingSystemTypeEnum.SHADING + + +transport = IfcBuildingSystemTypeEnum.TRANSPORT + + +userdefined = IfcBuildingSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuildingSystemTypeEnum.NOTDEFINED + + +IfcBurnerTypeEnum = enum_namespace() + + +userdefined = IfcBurnerTypeEnum.USERDEFINED + + +notdefined = IfcBurnerTypeEnum.NOTDEFINED + + +IfcCableCarrierFittingTypeEnum = enum_namespace() + + +bend = IfcCableCarrierFittingTypeEnum.BEND + + +cross = IfcCableCarrierFittingTypeEnum.CROSS + + +reducer = IfcCableCarrierFittingTypeEnum.REDUCER + + +tee = IfcCableCarrierFittingTypeEnum.TEE + + +userdefined = IfcCableCarrierFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierFittingTypeEnum.NOTDEFINED + + +IfcCableCarrierSegmentTypeEnum = enum_namespace() + + +cableladdersegment = IfcCableCarrierSegmentTypeEnum.CABLELADDERSEGMENT + + +cabletraysegment = IfcCableCarrierSegmentTypeEnum.CABLETRAYSEGMENT + + +cabletrunkingsegment = IfcCableCarrierSegmentTypeEnum.CABLETRUNKINGSEGMENT + + +conduitsegment = IfcCableCarrierSegmentTypeEnum.CONDUITSEGMENT + + +userdefined = IfcCableCarrierSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierSegmentTypeEnum.NOTDEFINED + + +IfcCableFittingTypeEnum = enum_namespace() + + +connector = IfcCableFittingTypeEnum.CONNECTOR + + +entry = IfcCableFittingTypeEnum.ENTRY + + +exit = IfcCableFittingTypeEnum.EXIT + + +junction = IfcCableFittingTypeEnum.JUNCTION + + +transition = IfcCableFittingTypeEnum.TRANSITION + + +userdefined = IfcCableFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableFittingTypeEnum.NOTDEFINED + + +IfcCableSegmentTypeEnum = enum_namespace() + + +busbarsegment = IfcCableSegmentTypeEnum.BUSBARSEGMENT + + +cablesegment = IfcCableSegmentTypeEnum.CABLESEGMENT + + +conductorsegment = IfcCableSegmentTypeEnum.CONDUCTORSEGMENT + + +coresegment = IfcCableSegmentTypeEnum.CORESEGMENT + + +userdefined = IfcCableSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableSegmentTypeEnum.NOTDEFINED + + +IfcChangeActionEnum = enum_namespace() + + +nochange = IfcChangeActionEnum.NOCHANGE + + +modified = IfcChangeActionEnum.MODIFIED + + +added = IfcChangeActionEnum.ADDED + + +deleted = IfcChangeActionEnum.DELETED + + +notdefined = IfcChangeActionEnum.NOTDEFINED + + +IfcChillerTypeEnum = enum_namespace() + + +aircooled = IfcChillerTypeEnum.AIRCOOLED + + +watercooled = IfcChillerTypeEnum.WATERCOOLED + + +heatrecovery = IfcChillerTypeEnum.HEATRECOVERY + + +userdefined = IfcChillerTypeEnum.USERDEFINED + + +notdefined = IfcChillerTypeEnum.NOTDEFINED + + +IfcChimneyTypeEnum = enum_namespace() + + +userdefined = IfcChimneyTypeEnum.USERDEFINED + + +notdefined = IfcChimneyTypeEnum.NOTDEFINED + + +IfcCoilTypeEnum = enum_namespace() + + +dxcoolingcoil = IfcCoilTypeEnum.DXCOOLINGCOIL + + +electricheatingcoil = IfcCoilTypeEnum.ELECTRICHEATINGCOIL + + +gasheatingcoil = IfcCoilTypeEnum.GASHEATINGCOIL + + +hydroniccoil = IfcCoilTypeEnum.HYDRONICCOIL + + +steamheatingcoil = IfcCoilTypeEnum.STEAMHEATINGCOIL + + +watercoolingcoil = IfcCoilTypeEnum.WATERCOOLINGCOIL + + +waterheatingcoil = IfcCoilTypeEnum.WATERHEATINGCOIL + + +userdefined = IfcCoilTypeEnum.USERDEFINED + + +notdefined = IfcCoilTypeEnum.NOTDEFINED + + +IfcColumnTypeEnum = enum_namespace() + + +column = IfcColumnTypeEnum.COLUMN + + +pilaster = IfcColumnTypeEnum.PILASTER + + +userdefined = IfcColumnTypeEnum.USERDEFINED + + +notdefined = IfcColumnTypeEnum.NOTDEFINED + + +IfcCommunicationsApplianceTypeEnum = enum_namespace() + + +antenna = IfcCommunicationsApplianceTypeEnum.ANTENNA + + +computer = IfcCommunicationsApplianceTypeEnum.COMPUTER + + +fax = IfcCommunicationsApplianceTypeEnum.FAX + + +gateway = IfcCommunicationsApplianceTypeEnum.GATEWAY + + +modem = IfcCommunicationsApplianceTypeEnum.MODEM + + +networkappliance = IfcCommunicationsApplianceTypeEnum.NETWORKAPPLIANCE + + +networkbridge = IfcCommunicationsApplianceTypeEnum.NETWORKBRIDGE + + +networkhub = IfcCommunicationsApplianceTypeEnum.NETWORKHUB + + +printer = IfcCommunicationsApplianceTypeEnum.PRINTER + + +repeater = IfcCommunicationsApplianceTypeEnum.REPEATER + + +router = IfcCommunicationsApplianceTypeEnum.ROUTER + + +scanner = IfcCommunicationsApplianceTypeEnum.SCANNER + + +userdefined = IfcCommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcCommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcComplexPropertyTemplateTypeEnum = enum_namespace() + + +p_complex = IfcComplexPropertyTemplateTypeEnum.P_COMPLEX + + +q_complex = IfcComplexPropertyTemplateTypeEnum.Q_COMPLEX + + +IfcCompressorTypeEnum = enum_namespace() + + +dynamic = IfcCompressorTypeEnum.DYNAMIC + + +reciprocating = IfcCompressorTypeEnum.RECIPROCATING + + +rotary = IfcCompressorTypeEnum.ROTARY + + +scroll = IfcCompressorTypeEnum.SCROLL + + +trochoidal = IfcCompressorTypeEnum.TROCHOIDAL + + +singlestage = IfcCompressorTypeEnum.SINGLESTAGE + + +booster = IfcCompressorTypeEnum.BOOSTER + + +opentype = IfcCompressorTypeEnum.OPENTYPE + + +hermetic = IfcCompressorTypeEnum.HERMETIC + + +semihermetic = IfcCompressorTypeEnum.SEMIHERMETIC + + +weldedshellhermetic = IfcCompressorTypeEnum.WELDEDSHELLHERMETIC + + +rollingpiston = IfcCompressorTypeEnum.ROLLINGPISTON + + +rotaryvane = IfcCompressorTypeEnum.ROTARYVANE + + +singlescrew = IfcCompressorTypeEnum.SINGLESCREW + + +twinscrew = IfcCompressorTypeEnum.TWINSCREW + + +userdefined = IfcCompressorTypeEnum.USERDEFINED + + +notdefined = IfcCompressorTypeEnum.NOTDEFINED + + +IfcCondenserTypeEnum = enum_namespace() + + +aircooled = IfcCondenserTypeEnum.AIRCOOLED + + +evaporativecooled = IfcCondenserTypeEnum.EVAPORATIVECOOLED + + +watercooled = IfcCondenserTypeEnum.WATERCOOLED + + +watercooledbrazedplate = IfcCondenserTypeEnum.WATERCOOLEDBRAZEDPLATE + + +watercooledshellcoil = IfcCondenserTypeEnum.WATERCOOLEDSHELLCOIL + + +watercooledshelltube = IfcCondenserTypeEnum.WATERCOOLEDSHELLTUBE + + +watercooledtubeintube = IfcCondenserTypeEnum.WATERCOOLEDTUBEINTUBE + + +userdefined = IfcCondenserTypeEnum.USERDEFINED + + +notdefined = IfcCondenserTypeEnum.NOTDEFINED + + +IfcConnectionTypeEnum = enum_namespace() + + +atpath = IfcConnectionTypeEnum.ATPATH + + +atstart = IfcConnectionTypeEnum.ATSTART + + +atend = IfcConnectionTypeEnum.ATEND + + +notdefined = IfcConnectionTypeEnum.NOTDEFINED + + +IfcConstraintEnum = enum_namespace() + + +hard = IfcConstraintEnum.HARD + + +soft = IfcConstraintEnum.SOFT + + +advisory = IfcConstraintEnum.ADVISORY + + +userdefined = IfcConstraintEnum.USERDEFINED + + +notdefined = IfcConstraintEnum.NOTDEFINED + + +IfcConstructionEquipmentResourceTypeEnum = enum_namespace() + + +demolishing = IfcConstructionEquipmentResourceTypeEnum.DEMOLISHING + + +earthmoving = IfcConstructionEquipmentResourceTypeEnum.EARTHMOVING + + +erecting = IfcConstructionEquipmentResourceTypeEnum.ERECTING + + +heating = IfcConstructionEquipmentResourceTypeEnum.HEATING + + +lighting = IfcConstructionEquipmentResourceTypeEnum.LIGHTING + + +paving = IfcConstructionEquipmentResourceTypeEnum.PAVING + + +pumping = IfcConstructionEquipmentResourceTypeEnum.PUMPING + + +transporting = IfcConstructionEquipmentResourceTypeEnum.TRANSPORTING + + +userdefined = IfcConstructionEquipmentResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionEquipmentResourceTypeEnum.NOTDEFINED + + +IfcConstructionMaterialResourceTypeEnum = enum_namespace() + + +aggregates = IfcConstructionMaterialResourceTypeEnum.AGGREGATES + + +concrete = IfcConstructionMaterialResourceTypeEnum.CONCRETE + + +drywall = IfcConstructionMaterialResourceTypeEnum.DRYWALL + + +fuel = IfcConstructionMaterialResourceTypeEnum.FUEL + + +gypsum = IfcConstructionMaterialResourceTypeEnum.GYPSUM + + +masonry = IfcConstructionMaterialResourceTypeEnum.MASONRY + + +metal = IfcConstructionMaterialResourceTypeEnum.METAL + + +plastic = IfcConstructionMaterialResourceTypeEnum.PLASTIC + + +wood = IfcConstructionMaterialResourceTypeEnum.WOOD + + +notdefined = IfcConstructionMaterialResourceTypeEnum.NOTDEFINED + + +userdefined = IfcConstructionMaterialResourceTypeEnum.USERDEFINED + + +IfcConstructionProductResourceTypeEnum = enum_namespace() + + +assembly = IfcConstructionProductResourceTypeEnum.ASSEMBLY + + +formwork = IfcConstructionProductResourceTypeEnum.FORMWORK + + +userdefined = IfcConstructionProductResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionProductResourceTypeEnum.NOTDEFINED + + +IfcControllerTypeEnum = enum_namespace() + + +floating = IfcControllerTypeEnum.FLOATING + + +programmable = IfcControllerTypeEnum.PROGRAMMABLE + + +proportional = IfcControllerTypeEnum.PROPORTIONAL + + +multiposition = IfcControllerTypeEnum.MULTIPOSITION + + +twoposition = IfcControllerTypeEnum.TWOPOSITION + + +userdefined = IfcControllerTypeEnum.USERDEFINED + + +notdefined = IfcControllerTypeEnum.NOTDEFINED + + +IfcCooledBeamTypeEnum = enum_namespace() + + +active = IfcCooledBeamTypeEnum.ACTIVE + + +passive = IfcCooledBeamTypeEnum.PASSIVE + + +userdefined = IfcCooledBeamTypeEnum.USERDEFINED + + +notdefined = IfcCooledBeamTypeEnum.NOTDEFINED + + +IfcCoolingTowerTypeEnum = enum_namespace() + + +naturaldraft = IfcCoolingTowerTypeEnum.NATURALDRAFT + + +mechanicalinduceddraft = IfcCoolingTowerTypeEnum.MECHANICALINDUCEDDRAFT + + +mechanicalforceddraft = IfcCoolingTowerTypeEnum.MECHANICALFORCEDDRAFT + + +userdefined = IfcCoolingTowerTypeEnum.USERDEFINED + + +notdefined = IfcCoolingTowerTypeEnum.NOTDEFINED + + +IfcCostItemTypeEnum = enum_namespace() + + +userdefined = IfcCostItemTypeEnum.USERDEFINED + + +notdefined = IfcCostItemTypeEnum.NOTDEFINED + + +IfcCostScheduleTypeEnum = enum_namespace() + + +budget = IfcCostScheduleTypeEnum.BUDGET + + +costplan = IfcCostScheduleTypeEnum.COSTPLAN + + +estimate = IfcCostScheduleTypeEnum.ESTIMATE + + +tender = IfcCostScheduleTypeEnum.TENDER + + +pricedbillofquantities = IfcCostScheduleTypeEnum.PRICEDBILLOFQUANTITIES + + +unpricedbillofquantities = IfcCostScheduleTypeEnum.UNPRICEDBILLOFQUANTITIES + + +scheduleofrates = IfcCostScheduleTypeEnum.SCHEDULEOFRATES + + +userdefined = IfcCostScheduleTypeEnum.USERDEFINED + + +notdefined = IfcCostScheduleTypeEnum.NOTDEFINED + + +IfcCoveringTypeEnum = enum_namespace() + + +ceiling = IfcCoveringTypeEnum.CEILING + + +flooring = IfcCoveringTypeEnum.FLOORING + + +cladding = IfcCoveringTypeEnum.CLADDING + + +roofing = IfcCoveringTypeEnum.ROOFING + + +molding = IfcCoveringTypeEnum.MOLDING + + +skirtingboard = IfcCoveringTypeEnum.SKIRTINGBOARD + + +insulation = IfcCoveringTypeEnum.INSULATION + + +membrane = IfcCoveringTypeEnum.MEMBRANE + + +sleeving = IfcCoveringTypeEnum.SLEEVING + + +wrapping = IfcCoveringTypeEnum.WRAPPING + + +userdefined = IfcCoveringTypeEnum.USERDEFINED + + +notdefined = IfcCoveringTypeEnum.NOTDEFINED + + +IfcCrewResourceTypeEnum = enum_namespace() + + +office = IfcCrewResourceTypeEnum.OFFICE + + +site = IfcCrewResourceTypeEnum.SITE + + +userdefined = IfcCrewResourceTypeEnum.USERDEFINED + + +notdefined = IfcCrewResourceTypeEnum.NOTDEFINED + + +IfcCurtainWallTypeEnum = enum_namespace() + + +userdefined = IfcCurtainWallTypeEnum.USERDEFINED + + +notdefined = IfcCurtainWallTypeEnum.NOTDEFINED + + +IfcCurveInterpolationEnum = enum_namespace() + + +linear = IfcCurveInterpolationEnum.LINEAR + + +log_linear = IfcCurveInterpolationEnum.LOG_LINEAR + + +log_log = IfcCurveInterpolationEnum.LOG_LOG + + +notdefined = IfcCurveInterpolationEnum.NOTDEFINED + + +IfcDamperTypeEnum = enum_namespace() + + +backdraftdamper = IfcDamperTypeEnum.BACKDRAFTDAMPER + + +balancingdamper = IfcDamperTypeEnum.BALANCINGDAMPER + + +blastdamper = IfcDamperTypeEnum.BLASTDAMPER + + +controldamper = IfcDamperTypeEnum.CONTROLDAMPER + + +firedamper = IfcDamperTypeEnum.FIREDAMPER + + +firesmokedamper = IfcDamperTypeEnum.FIRESMOKEDAMPER + + +fumehoodexhaust = IfcDamperTypeEnum.FUMEHOODEXHAUST + + +gravitydamper = IfcDamperTypeEnum.GRAVITYDAMPER + + +gravityreliefdamper = IfcDamperTypeEnum.GRAVITYRELIEFDAMPER + + +reliefdamper = IfcDamperTypeEnum.RELIEFDAMPER + + +smokedamper = IfcDamperTypeEnum.SMOKEDAMPER + + +userdefined = IfcDamperTypeEnum.USERDEFINED + + +notdefined = IfcDamperTypeEnum.NOTDEFINED + + +IfcDataOriginEnum = enum_namespace() + + +measured = IfcDataOriginEnum.MEASURED + + +predicted = IfcDataOriginEnum.PREDICTED + + +simulated = IfcDataOriginEnum.SIMULATED + + +userdefined = IfcDataOriginEnum.USERDEFINED + + +notdefined = IfcDataOriginEnum.NOTDEFINED + + +IfcDerivedUnitEnum = enum_namespace() + + +angularvelocityunit = IfcDerivedUnitEnum.ANGULARVELOCITYUNIT + + +areadensityunit = IfcDerivedUnitEnum.AREADENSITYUNIT + + +compoundplaneangleunit = IfcDerivedUnitEnum.COMPOUNDPLANEANGLEUNIT + + +dynamicviscosityunit = IfcDerivedUnitEnum.DYNAMICVISCOSITYUNIT + + +heatfluxdensityunit = IfcDerivedUnitEnum.HEATFLUXDENSITYUNIT + + +integercountrateunit = IfcDerivedUnitEnum.INTEGERCOUNTRATEUNIT + + +isothermalmoisturecapacityunit = IfcDerivedUnitEnum.ISOTHERMALMOISTURECAPACITYUNIT + + +kinematicviscosityunit = IfcDerivedUnitEnum.KINEMATICVISCOSITYUNIT + + +linearvelocityunit = IfcDerivedUnitEnum.LINEARVELOCITYUNIT + + +massdensityunit = IfcDerivedUnitEnum.MASSDENSITYUNIT + + +massflowrateunit = IfcDerivedUnitEnum.MASSFLOWRATEUNIT + + +moisturediffusivityunit = IfcDerivedUnitEnum.MOISTUREDIFFUSIVITYUNIT + + +molecularweightunit = IfcDerivedUnitEnum.MOLECULARWEIGHTUNIT + + +specificheatcapacityunit = IfcDerivedUnitEnum.SPECIFICHEATCAPACITYUNIT + + +thermaladmittanceunit = IfcDerivedUnitEnum.THERMALADMITTANCEUNIT + + +thermalconductanceunit = IfcDerivedUnitEnum.THERMALCONDUCTANCEUNIT + + +thermalresistanceunit = IfcDerivedUnitEnum.THERMALRESISTANCEUNIT + + +thermaltransmittanceunit = IfcDerivedUnitEnum.THERMALTRANSMITTANCEUNIT + + +vaporpermeabilityunit = IfcDerivedUnitEnum.VAPORPERMEABILITYUNIT + + +volumetricflowrateunit = IfcDerivedUnitEnum.VOLUMETRICFLOWRATEUNIT + + +rotationalfrequencyunit = IfcDerivedUnitEnum.ROTATIONALFREQUENCYUNIT + + +torqueunit = IfcDerivedUnitEnum.TORQUEUNIT + + +momentofinertiaunit = IfcDerivedUnitEnum.MOMENTOFINERTIAUNIT + + +linearmomentunit = IfcDerivedUnitEnum.LINEARMOMENTUNIT + + +linearforceunit = IfcDerivedUnitEnum.LINEARFORCEUNIT + + +planarforceunit = IfcDerivedUnitEnum.PLANARFORCEUNIT + + +modulusofelasticityunit = IfcDerivedUnitEnum.MODULUSOFELASTICITYUNIT + + +shearmodulusunit = IfcDerivedUnitEnum.SHEARMODULUSUNIT + + +linearstiffnessunit = IfcDerivedUnitEnum.LINEARSTIFFNESSUNIT + + +rotationalstiffnessunit = IfcDerivedUnitEnum.ROTATIONALSTIFFNESSUNIT + + +modulusofsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFSUBGRADEREACTIONUNIT + + +accelerationunit = IfcDerivedUnitEnum.ACCELERATIONUNIT + + +curvatureunit = IfcDerivedUnitEnum.CURVATUREUNIT + + +heatingvalueunit = IfcDerivedUnitEnum.HEATINGVALUEUNIT + + +ionconcentrationunit = IfcDerivedUnitEnum.IONCONCENTRATIONUNIT + + +luminousintensitydistributionunit = IfcDerivedUnitEnum.LUMINOUSINTENSITYDISTRIBUTIONUNIT + + +massperlengthunit = IfcDerivedUnitEnum.MASSPERLENGTHUNIT + + +modulusoflinearsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFLINEARSUBGRADEREACTIONUNIT + + +modulusofrotationalsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFROTATIONALSUBGRADEREACTIONUNIT + + +phunit = IfcDerivedUnitEnum.PHUNIT + + +rotationalmassunit = IfcDerivedUnitEnum.ROTATIONALMASSUNIT + + +sectionareaintegralunit = IfcDerivedUnitEnum.SECTIONAREAINTEGRALUNIT + + +sectionmodulusunit = IfcDerivedUnitEnum.SECTIONMODULUSUNIT + + +soundpowerlevelunit = IfcDerivedUnitEnum.SOUNDPOWERLEVELUNIT + + +soundpowerunit = IfcDerivedUnitEnum.SOUNDPOWERUNIT + + +soundpressurelevelunit = IfcDerivedUnitEnum.SOUNDPRESSURELEVELUNIT + + +soundpressureunit = IfcDerivedUnitEnum.SOUNDPRESSUREUNIT + + +temperaturegradientunit = IfcDerivedUnitEnum.TEMPERATUREGRADIENTUNIT + + +temperaturerateofchangeunit = IfcDerivedUnitEnum.TEMPERATURERATEOFCHANGEUNIT + + +thermalexpansioncoefficientunit = IfcDerivedUnitEnum.THERMALEXPANSIONCOEFFICIENTUNIT + + +warpingconstantunit = IfcDerivedUnitEnum.WARPINGCONSTANTUNIT + + +warpingmomentunit = IfcDerivedUnitEnum.WARPINGMOMENTUNIT + + +userdefined = IfcDerivedUnitEnum.USERDEFINED + + +IfcDirectionSenseEnum = enum_namespace() + + +positive = IfcDirectionSenseEnum.POSITIVE + + +negative = IfcDirectionSenseEnum.NEGATIVE + + +IfcDiscreteAccessoryTypeEnum = enum_namespace() + + +anchorplate = IfcDiscreteAccessoryTypeEnum.ANCHORPLATE + + +bracket = IfcDiscreteAccessoryTypeEnum.BRACKET + + +shoe = IfcDiscreteAccessoryTypeEnum.SHOE + + +userdefined = IfcDiscreteAccessoryTypeEnum.USERDEFINED + + +notdefined = IfcDiscreteAccessoryTypeEnum.NOTDEFINED + + +IfcDistributionChamberElementTypeEnum = enum_namespace() + + +formedduct = IfcDistributionChamberElementTypeEnum.FORMEDDUCT + + +inspectionchamber = IfcDistributionChamberElementTypeEnum.INSPECTIONCHAMBER + + +inspectionpit = IfcDistributionChamberElementTypeEnum.INSPECTIONPIT + + +manhole = IfcDistributionChamberElementTypeEnum.MANHOLE + + +meterchamber = IfcDistributionChamberElementTypeEnum.METERCHAMBER + + +sump = IfcDistributionChamberElementTypeEnum.SUMP + + +trench = IfcDistributionChamberElementTypeEnum.TRENCH + + +valvechamber = IfcDistributionChamberElementTypeEnum.VALVECHAMBER + + +userdefined = IfcDistributionChamberElementTypeEnum.USERDEFINED + + +notdefined = IfcDistributionChamberElementTypeEnum.NOTDEFINED + + +IfcDistributionPortTypeEnum = enum_namespace() + + +cable = IfcDistributionPortTypeEnum.CABLE + + +cablecarrier = IfcDistributionPortTypeEnum.CABLECARRIER + + +duct = IfcDistributionPortTypeEnum.DUCT + + +pipe = IfcDistributionPortTypeEnum.PIPE + + +userdefined = IfcDistributionPortTypeEnum.USERDEFINED + + +notdefined = IfcDistributionPortTypeEnum.NOTDEFINED + + +IfcDistributionSystemEnum = enum_namespace() + + +airconditioning = IfcDistributionSystemEnum.AIRCONDITIONING + + +audiovisual = IfcDistributionSystemEnum.AUDIOVISUAL + + +chemical = IfcDistributionSystemEnum.CHEMICAL + + +chilledwater = IfcDistributionSystemEnum.CHILLEDWATER + + +communication = IfcDistributionSystemEnum.COMMUNICATION + + +compressedair = IfcDistributionSystemEnum.COMPRESSEDAIR + + +condenserwater = IfcDistributionSystemEnum.CONDENSERWATER + + +control = IfcDistributionSystemEnum.CONTROL + + +conveying = IfcDistributionSystemEnum.CONVEYING + + +data = IfcDistributionSystemEnum.DATA + + +disposal = IfcDistributionSystemEnum.DISPOSAL + + +domesticcoldwater = IfcDistributionSystemEnum.DOMESTICCOLDWATER + + +domestichotwater = IfcDistributionSystemEnum.DOMESTICHOTWATER + + +drainage = IfcDistributionSystemEnum.DRAINAGE + + +earthing = IfcDistributionSystemEnum.EARTHING + + +electrical = IfcDistributionSystemEnum.ELECTRICAL + + +electroacoustic = IfcDistributionSystemEnum.ELECTROACOUSTIC + + +exhaust = IfcDistributionSystemEnum.EXHAUST + + +fireprotection = IfcDistributionSystemEnum.FIREPROTECTION + + +fuel = IfcDistributionSystemEnum.FUEL + + +gas = IfcDistributionSystemEnum.GAS + + +hazardous = IfcDistributionSystemEnum.HAZARDOUS + + +heating = IfcDistributionSystemEnum.HEATING + + +lighting = IfcDistributionSystemEnum.LIGHTING + + +lightningprotection = IfcDistributionSystemEnum.LIGHTNINGPROTECTION + + +municipalsolidwaste = IfcDistributionSystemEnum.MUNICIPALSOLIDWASTE + + +oil = IfcDistributionSystemEnum.OIL + + +operational = IfcDistributionSystemEnum.OPERATIONAL + + +powergeneration = IfcDistributionSystemEnum.POWERGENERATION + + +rainwater = IfcDistributionSystemEnum.RAINWATER + + +refrigeration = IfcDistributionSystemEnum.REFRIGERATION + + +security = IfcDistributionSystemEnum.SECURITY + + +sewage = IfcDistributionSystemEnum.SEWAGE + + +signal = IfcDistributionSystemEnum.SIGNAL + + +stormwater = IfcDistributionSystemEnum.STORMWATER + + +telephone = IfcDistributionSystemEnum.TELEPHONE + + +tv = IfcDistributionSystemEnum.TV + + +vacuum = IfcDistributionSystemEnum.VACUUM + + +vent = IfcDistributionSystemEnum.VENT + + +ventilation = IfcDistributionSystemEnum.VENTILATION + + +wastewater = IfcDistributionSystemEnum.WASTEWATER + + +watersupply = IfcDistributionSystemEnum.WATERSUPPLY + + +userdefined = IfcDistributionSystemEnum.USERDEFINED + + +notdefined = IfcDistributionSystemEnum.NOTDEFINED + + +IfcDocumentConfidentialityEnum = enum_namespace() + + +public = IfcDocumentConfidentialityEnum.PUBLIC + + +restricted = IfcDocumentConfidentialityEnum.RESTRICTED + + +confidential = IfcDocumentConfidentialityEnum.CONFIDENTIAL + + +personal = IfcDocumentConfidentialityEnum.PERSONAL + + +userdefined = IfcDocumentConfidentialityEnum.USERDEFINED + + +notdefined = IfcDocumentConfidentialityEnum.NOTDEFINED + + +IfcDocumentStatusEnum = enum_namespace() + + +draft = IfcDocumentStatusEnum.DRAFT + + +finaldraft = IfcDocumentStatusEnum.FINALDRAFT + + +final = IfcDocumentStatusEnum.FINAL + + +revision = IfcDocumentStatusEnum.REVISION + + +notdefined = IfcDocumentStatusEnum.NOTDEFINED + + +IfcDoorPanelOperationEnum = enum_namespace() + + +swinging = IfcDoorPanelOperationEnum.SWINGING + + +double_acting = IfcDoorPanelOperationEnum.DOUBLE_ACTING + + +sliding = IfcDoorPanelOperationEnum.SLIDING + + +folding = IfcDoorPanelOperationEnum.FOLDING + + +revolving = IfcDoorPanelOperationEnum.REVOLVING + + +rollingup = IfcDoorPanelOperationEnum.ROLLINGUP + + +fixedpanel = IfcDoorPanelOperationEnum.FIXEDPANEL + + +userdefined = IfcDoorPanelOperationEnum.USERDEFINED + + +notdefined = IfcDoorPanelOperationEnum.NOTDEFINED + + +IfcDoorPanelPositionEnum = enum_namespace() + + +left = IfcDoorPanelPositionEnum.LEFT + + +middle = IfcDoorPanelPositionEnum.MIDDLE + + +right = IfcDoorPanelPositionEnum.RIGHT + + +notdefined = IfcDoorPanelPositionEnum.NOTDEFINED + + +IfcDoorStyleConstructionEnum = enum_namespace() + + +aluminium = IfcDoorStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcDoorStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcDoorStyleConstructionEnum.STEEL + + +wood = IfcDoorStyleConstructionEnum.WOOD + + +aluminium_wood = IfcDoorStyleConstructionEnum.ALUMINIUM_WOOD + + +aluminium_plastic = IfcDoorStyleConstructionEnum.ALUMINIUM_PLASTIC + + +plastic = IfcDoorStyleConstructionEnum.PLASTIC + + +userdefined = IfcDoorStyleConstructionEnum.USERDEFINED + + +notdefined = IfcDoorStyleConstructionEnum.NOTDEFINED + + +IfcDoorStyleOperationEnum = enum_namespace() + + +single_swing_left = IfcDoorStyleOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorStyleOperationEnum.SINGLE_SWING_RIGHT + + +double_door_single_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_swing_left = IfcDoorStyleOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorStyleOperationEnum.DOUBLE_SWING_RIGHT + + +double_door_double_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +sliding_to_left = IfcDoorStyleOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorStyleOperationEnum.SLIDING_TO_RIGHT + + +double_door_sliding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SLIDING + + +folding_to_left = IfcDoorStyleOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorStyleOperationEnum.FOLDING_TO_RIGHT + + +double_door_folding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_FOLDING + + +revolving = IfcDoorStyleOperationEnum.REVOLVING + + +rollingup = IfcDoorStyleOperationEnum.ROLLINGUP + + +userdefined = IfcDoorStyleOperationEnum.USERDEFINED + + +notdefined = IfcDoorStyleOperationEnum.NOTDEFINED + + +IfcDoorTypeEnum = enum_namespace() + + +door = IfcDoorTypeEnum.DOOR + + +gate = IfcDoorTypeEnum.GATE + + +trapdoor = IfcDoorTypeEnum.TRAPDOOR + + +userdefined = IfcDoorTypeEnum.USERDEFINED + + +notdefined = IfcDoorTypeEnum.NOTDEFINED + + +IfcDoorTypeOperationEnum = enum_namespace() + + +single_swing_left = IfcDoorTypeOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorTypeOperationEnum.SINGLE_SWING_RIGHT + + +double_door_single_swing = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_swing_left = IfcDoorTypeOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorTypeOperationEnum.DOUBLE_SWING_RIGHT + + +double_door_double_swing = IfcDoorTypeOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +sliding_to_left = IfcDoorTypeOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorTypeOperationEnum.SLIDING_TO_RIGHT + + +double_door_sliding = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SLIDING + + +folding_to_left = IfcDoorTypeOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorTypeOperationEnum.FOLDING_TO_RIGHT + + +double_door_folding = IfcDoorTypeOperationEnum.DOUBLE_DOOR_FOLDING + + +revolving = IfcDoorTypeOperationEnum.REVOLVING + + +rollingup = IfcDoorTypeOperationEnum.ROLLINGUP + + +swing_fixed_left = IfcDoorTypeOperationEnum.SWING_FIXED_LEFT + + +swing_fixed_right = IfcDoorTypeOperationEnum.SWING_FIXED_RIGHT + + +userdefined = IfcDoorTypeOperationEnum.USERDEFINED + + +notdefined = IfcDoorTypeOperationEnum.NOTDEFINED + + +IfcDuctFittingTypeEnum = enum_namespace() + + +bend = IfcDuctFittingTypeEnum.BEND + + +connector = IfcDuctFittingTypeEnum.CONNECTOR + + +entry = IfcDuctFittingTypeEnum.ENTRY + + +exit = IfcDuctFittingTypeEnum.EXIT + + +junction = IfcDuctFittingTypeEnum.JUNCTION + + +obstruction = IfcDuctFittingTypeEnum.OBSTRUCTION + + +transition = IfcDuctFittingTypeEnum.TRANSITION + + +userdefined = IfcDuctFittingTypeEnum.USERDEFINED + + +notdefined = IfcDuctFittingTypeEnum.NOTDEFINED + + +IfcDuctSegmentTypeEnum = enum_namespace() + + +rigidsegment = IfcDuctSegmentTypeEnum.RIGIDSEGMENT + + +flexiblesegment = IfcDuctSegmentTypeEnum.FLEXIBLESEGMENT + + +userdefined = IfcDuctSegmentTypeEnum.USERDEFINED + + +notdefined = IfcDuctSegmentTypeEnum.NOTDEFINED + + +IfcDuctSilencerTypeEnum = enum_namespace() + + +flatoval = IfcDuctSilencerTypeEnum.FLATOVAL + + +rectangular = IfcDuctSilencerTypeEnum.RECTANGULAR + + +round = IfcDuctSilencerTypeEnum.ROUND + + +userdefined = IfcDuctSilencerTypeEnum.USERDEFINED + + +notdefined = IfcDuctSilencerTypeEnum.NOTDEFINED + + +IfcElectricApplianceTypeEnum = enum_namespace() + + +dishwasher = IfcElectricApplianceTypeEnum.DISHWASHER + + +electriccooker = IfcElectricApplianceTypeEnum.ELECTRICCOOKER + + +freestandingelectricheater = IfcElectricApplianceTypeEnum.FREESTANDINGELECTRICHEATER + + +freestandingfan = IfcElectricApplianceTypeEnum.FREESTANDINGFAN + + +freestandingwaterheater = IfcElectricApplianceTypeEnum.FREESTANDINGWATERHEATER + + +freestandingwatercooler = IfcElectricApplianceTypeEnum.FREESTANDINGWATERCOOLER + + +freezer = IfcElectricApplianceTypeEnum.FREEZER + + +fridge_freezer = IfcElectricApplianceTypeEnum.FRIDGE_FREEZER + + +handdryer = IfcElectricApplianceTypeEnum.HANDDRYER + + +kitchenmachine = IfcElectricApplianceTypeEnum.KITCHENMACHINE + + +microwave = IfcElectricApplianceTypeEnum.MICROWAVE + + +photocopier = IfcElectricApplianceTypeEnum.PHOTOCOPIER + + +refrigerator = IfcElectricApplianceTypeEnum.REFRIGERATOR + + +tumbledryer = IfcElectricApplianceTypeEnum.TUMBLEDRYER + + +vendingmachine = IfcElectricApplianceTypeEnum.VENDINGMACHINE + + +washingmachine = IfcElectricApplianceTypeEnum.WASHINGMACHINE + + +userdefined = IfcElectricApplianceTypeEnum.USERDEFINED + + +notdefined = IfcElectricApplianceTypeEnum.NOTDEFINED + + +IfcElectricDistributionBoardTypeEnum = enum_namespace() + + +consumerunit = IfcElectricDistributionBoardTypeEnum.CONSUMERUNIT + + +distributionboard = IfcElectricDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +motorcontrolcentre = IfcElectricDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +switchboard = IfcElectricDistributionBoardTypeEnum.SWITCHBOARD + + +userdefined = IfcElectricDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcElectricDistributionBoardTypeEnum.NOTDEFINED + + +IfcElectricFlowStorageDeviceTypeEnum = enum_namespace() + + +battery = IfcElectricFlowStorageDeviceTypeEnum.BATTERY + + +capacitorbank = IfcElectricFlowStorageDeviceTypeEnum.CAPACITORBANK + + +harmonicfilter = IfcElectricFlowStorageDeviceTypeEnum.HARMONICFILTER + + +inductorbank = IfcElectricFlowStorageDeviceTypeEnum.INDUCTORBANK + + +ups = IfcElectricFlowStorageDeviceTypeEnum.UPS + + +userdefined = IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowStorageDeviceTypeEnum.NOTDEFINED + + +IfcElectricGeneratorTypeEnum = enum_namespace() + + +chp = IfcElectricGeneratorTypeEnum.CHP + + +enginegenerator = IfcElectricGeneratorTypeEnum.ENGINEGENERATOR + + +standalone = IfcElectricGeneratorTypeEnum.STANDALONE + + +userdefined = IfcElectricGeneratorTypeEnum.USERDEFINED + + +notdefined = IfcElectricGeneratorTypeEnum.NOTDEFINED + + +IfcElectricMotorTypeEnum = enum_namespace() + + +dc = IfcElectricMotorTypeEnum.DC + + +induction = IfcElectricMotorTypeEnum.INDUCTION + + +polyphase = IfcElectricMotorTypeEnum.POLYPHASE + + +reluctancesynchronous = IfcElectricMotorTypeEnum.RELUCTANCESYNCHRONOUS + + +synchronous = IfcElectricMotorTypeEnum.SYNCHRONOUS + + +userdefined = IfcElectricMotorTypeEnum.USERDEFINED + + +notdefined = IfcElectricMotorTypeEnum.NOTDEFINED + + +IfcElectricTimeControlTypeEnum = enum_namespace() + + +timeclock = IfcElectricTimeControlTypeEnum.TIMECLOCK + + +timedelay = IfcElectricTimeControlTypeEnum.TIMEDELAY + + +relay = IfcElectricTimeControlTypeEnum.RELAY + + +userdefined = IfcElectricTimeControlTypeEnum.USERDEFINED + + +notdefined = IfcElectricTimeControlTypeEnum.NOTDEFINED + + +IfcElementAssemblyTypeEnum = enum_namespace() + + +accessory_assembly = IfcElementAssemblyTypeEnum.ACCESSORY_ASSEMBLY + + +arch = IfcElementAssemblyTypeEnum.ARCH + + +beam_grid = IfcElementAssemblyTypeEnum.BEAM_GRID + + +braced_frame = IfcElementAssemblyTypeEnum.BRACED_FRAME + + +girder = IfcElementAssemblyTypeEnum.GIRDER + + +reinforcement_unit = IfcElementAssemblyTypeEnum.REINFORCEMENT_UNIT + + +rigid_frame = IfcElementAssemblyTypeEnum.RIGID_FRAME + + +slab_field = IfcElementAssemblyTypeEnum.SLAB_FIELD + + +truss = IfcElementAssemblyTypeEnum.TRUSS + + +userdefined = IfcElementAssemblyTypeEnum.USERDEFINED + + +notdefined = IfcElementAssemblyTypeEnum.NOTDEFINED + + +IfcElementCompositionEnum = enum_namespace() + + +complex = IfcElementCompositionEnum.COMPLEX + + +element = IfcElementCompositionEnum.ELEMENT + + +partial = IfcElementCompositionEnum.PARTIAL + + +IfcEngineTypeEnum = enum_namespace() + + +externalcombustion = IfcEngineTypeEnum.EXTERNALCOMBUSTION + + +internalcombustion = IfcEngineTypeEnum.INTERNALCOMBUSTION + + +userdefined = IfcEngineTypeEnum.USERDEFINED + + +notdefined = IfcEngineTypeEnum.NOTDEFINED + + +IfcEvaporativeCoolerTypeEnum = enum_namespace() + + +directevaporativerandommediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER + + +directevaporativerigidmediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER + + +directevaporativeslingerspackagedaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER + + +directevaporativepackagedrotaryaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER + + +directevaporativeairwasher = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEAIRWASHER + + +indirectevaporativepackageaircooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEPACKAGEAIRCOOLER + + +indirectevaporativewetcoil = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEWETCOIL + + +indirectevaporativecoolingtowerorcoilcooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER + + +indirectdirectcombination = IfcEvaporativeCoolerTypeEnum.INDIRECTDIRECTCOMBINATION + + +userdefined = IfcEvaporativeCoolerTypeEnum.USERDEFINED + + +notdefined = IfcEvaporativeCoolerTypeEnum.NOTDEFINED + + +IfcEvaporatorTypeEnum = enum_namespace() + + +directexpansion = IfcEvaporatorTypeEnum.DIRECTEXPANSION + + +directexpansionshellandtube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONSHELLANDTUBE + + +directexpansiontubeintube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONTUBEINTUBE + + +directexpansionbrazedplate = IfcEvaporatorTypeEnum.DIRECTEXPANSIONBRAZEDPLATE + + +floodedshellandtube = IfcEvaporatorTypeEnum.FLOODEDSHELLANDTUBE + + +shellandcoil = IfcEvaporatorTypeEnum.SHELLANDCOIL + + +userdefined = IfcEvaporatorTypeEnum.USERDEFINED + + +notdefined = IfcEvaporatorTypeEnum.NOTDEFINED + + +IfcEventTriggerTypeEnum = enum_namespace() + + +eventrule = IfcEventTriggerTypeEnum.EVENTRULE + + +eventmessage = IfcEventTriggerTypeEnum.EVENTMESSAGE + + +eventtime = IfcEventTriggerTypeEnum.EVENTTIME + + +eventcomplex = IfcEventTriggerTypeEnum.EVENTCOMPLEX + + +userdefined = IfcEventTriggerTypeEnum.USERDEFINED + + +notdefined = IfcEventTriggerTypeEnum.NOTDEFINED + + +IfcEventTypeEnum = enum_namespace() + + +startevent = IfcEventTypeEnum.STARTEVENT + + +endevent = IfcEventTypeEnum.ENDEVENT + + +intermediateevent = IfcEventTypeEnum.INTERMEDIATEEVENT + + +userdefined = IfcEventTypeEnum.USERDEFINED + + +notdefined = IfcEventTypeEnum.NOTDEFINED + + +IfcExternalSpatialElementTypeEnum = enum_namespace() + + +external = IfcExternalSpatialElementTypeEnum.EXTERNAL + + +external_earth = IfcExternalSpatialElementTypeEnum.EXTERNAL_EARTH + + +external_water = IfcExternalSpatialElementTypeEnum.EXTERNAL_WATER + + +external_fire = IfcExternalSpatialElementTypeEnum.EXTERNAL_FIRE + + +userdefined = IfcExternalSpatialElementTypeEnum.USERDEFINED + + +notdefined = IfcExternalSpatialElementTypeEnum.NOTDEFINED + + +IfcFanTypeEnum = enum_namespace() + + +centrifugalforwardcurved = IfcFanTypeEnum.CENTRIFUGALFORWARDCURVED + + +centrifugalradial = IfcFanTypeEnum.CENTRIFUGALRADIAL + + +centrifugalbackwardinclinedcurved = IfcFanTypeEnum.CENTRIFUGALBACKWARDINCLINEDCURVED + + +centrifugalairfoil = IfcFanTypeEnum.CENTRIFUGALAIRFOIL + + +tubeaxial = IfcFanTypeEnum.TUBEAXIAL + + +vaneaxial = IfcFanTypeEnum.VANEAXIAL + + +propelloraxial = IfcFanTypeEnum.PROPELLORAXIAL + + +userdefined = IfcFanTypeEnum.USERDEFINED + + +notdefined = IfcFanTypeEnum.NOTDEFINED + + +IfcFastenerTypeEnum = enum_namespace() + + +glue = IfcFastenerTypeEnum.GLUE + + +mortar = IfcFastenerTypeEnum.MORTAR + + +weld = IfcFastenerTypeEnum.WELD + + +userdefined = IfcFastenerTypeEnum.USERDEFINED + + +notdefined = IfcFastenerTypeEnum.NOTDEFINED + + +IfcFilterTypeEnum = enum_namespace() + + +airparticlefilter = IfcFilterTypeEnum.AIRPARTICLEFILTER + + +compressedairfilter = IfcFilterTypeEnum.COMPRESSEDAIRFILTER + + +odorfilter = IfcFilterTypeEnum.ODORFILTER + + +oilfilter = IfcFilterTypeEnum.OILFILTER + + +strainer = IfcFilterTypeEnum.STRAINER + + +waterfilter = IfcFilterTypeEnum.WATERFILTER + + +userdefined = IfcFilterTypeEnum.USERDEFINED + + +notdefined = IfcFilterTypeEnum.NOTDEFINED + + +IfcFireSuppressionTerminalTypeEnum = enum_namespace() + + +breechinginlet = IfcFireSuppressionTerminalTypeEnum.BREECHINGINLET + + +firehydrant = IfcFireSuppressionTerminalTypeEnum.FIREHYDRANT + + +hosereel = IfcFireSuppressionTerminalTypeEnum.HOSEREEL + + +sprinkler = IfcFireSuppressionTerminalTypeEnum.SPRINKLER + + +sprinklerdeflector = IfcFireSuppressionTerminalTypeEnum.SPRINKLERDEFLECTOR + + +userdefined = IfcFireSuppressionTerminalTypeEnum.USERDEFINED + + +notdefined = IfcFireSuppressionTerminalTypeEnum.NOTDEFINED + + +IfcFlowDirectionEnum = enum_namespace() + + +source = IfcFlowDirectionEnum.SOURCE + + +sink = IfcFlowDirectionEnum.SINK + + +sourceandsink = IfcFlowDirectionEnum.SOURCEANDSINK + + +notdefined = IfcFlowDirectionEnum.NOTDEFINED + + +IfcFlowInstrumentTypeEnum = enum_namespace() + + +pressuregauge = IfcFlowInstrumentTypeEnum.PRESSUREGAUGE + + +thermometer = IfcFlowInstrumentTypeEnum.THERMOMETER + + +ammeter = IfcFlowInstrumentTypeEnum.AMMETER + + +frequencymeter = IfcFlowInstrumentTypeEnum.FREQUENCYMETER + + +powerfactormeter = IfcFlowInstrumentTypeEnum.POWERFACTORMETER + + +phaseanglemeter = IfcFlowInstrumentTypeEnum.PHASEANGLEMETER + + +voltmeter_peak = IfcFlowInstrumentTypeEnum.VOLTMETER_PEAK + + +voltmeter_rms = IfcFlowInstrumentTypeEnum.VOLTMETER_RMS + + +userdefined = IfcFlowInstrumentTypeEnum.USERDEFINED + + +notdefined = IfcFlowInstrumentTypeEnum.NOTDEFINED + + +IfcFlowMeterTypeEnum = enum_namespace() + + +energymeter = IfcFlowMeterTypeEnum.ENERGYMETER + + +gasmeter = IfcFlowMeterTypeEnum.GASMETER + + +oilmeter = IfcFlowMeterTypeEnum.OILMETER + + +watermeter = IfcFlowMeterTypeEnum.WATERMETER + + +userdefined = IfcFlowMeterTypeEnum.USERDEFINED + + +notdefined = IfcFlowMeterTypeEnum.NOTDEFINED + + +IfcFootingTypeEnum = enum_namespace() + + +caisson_foundation = IfcFootingTypeEnum.CAISSON_FOUNDATION + + +footing_beam = IfcFootingTypeEnum.FOOTING_BEAM + + +pad_footing = IfcFootingTypeEnum.PAD_FOOTING + + +pile_cap = IfcFootingTypeEnum.PILE_CAP + + +strip_footing = IfcFootingTypeEnum.STRIP_FOOTING + + +userdefined = IfcFootingTypeEnum.USERDEFINED + + +notdefined = IfcFootingTypeEnum.NOTDEFINED + + +IfcFurnitureTypeEnum = enum_namespace() + + +chair = IfcFurnitureTypeEnum.CHAIR + + +table = IfcFurnitureTypeEnum.TABLE + + +desk = IfcFurnitureTypeEnum.DESK + + +bed = IfcFurnitureTypeEnum.BED + + +filecabinet = IfcFurnitureTypeEnum.FILECABINET + + +shelf = IfcFurnitureTypeEnum.SHELF + + +sofa = IfcFurnitureTypeEnum.SOFA + + +userdefined = IfcFurnitureTypeEnum.USERDEFINED + + +notdefined = IfcFurnitureTypeEnum.NOTDEFINED + + +IfcGeographicElementTypeEnum = enum_namespace() + + +terrain = IfcGeographicElementTypeEnum.TERRAIN + + +userdefined = IfcGeographicElementTypeEnum.USERDEFINED + + +notdefined = IfcGeographicElementTypeEnum.NOTDEFINED + + +IfcGeometricProjectionEnum = enum_namespace() + + +graph_view = IfcGeometricProjectionEnum.GRAPH_VIEW + + +sketch_view = IfcGeometricProjectionEnum.SKETCH_VIEW + + +model_view = IfcGeometricProjectionEnum.MODEL_VIEW + + +plan_view = IfcGeometricProjectionEnum.PLAN_VIEW + + +reflected_plan_view = IfcGeometricProjectionEnum.REFLECTED_PLAN_VIEW + + +section_view = IfcGeometricProjectionEnum.SECTION_VIEW + + +elevation_view = IfcGeometricProjectionEnum.ELEVATION_VIEW + + +userdefined = IfcGeometricProjectionEnum.USERDEFINED + + +notdefined = IfcGeometricProjectionEnum.NOTDEFINED + + +IfcGlobalOrLocalEnum = enum_namespace() + + +global_coords = IfcGlobalOrLocalEnum.GLOBAL_COORDS + + +local_coords = IfcGlobalOrLocalEnum.LOCAL_COORDS + + +IfcGridTypeEnum = enum_namespace() + + +rectangular = IfcGridTypeEnum.RECTANGULAR + + +radial = IfcGridTypeEnum.RADIAL + + +triangular = IfcGridTypeEnum.TRIANGULAR + + +irregular = IfcGridTypeEnum.IRREGULAR + + +userdefined = IfcGridTypeEnum.USERDEFINED + + +notdefined = IfcGridTypeEnum.NOTDEFINED + + +IfcHeatExchangerTypeEnum = enum_namespace() + + +plate = IfcHeatExchangerTypeEnum.PLATE + + +shellandtube = IfcHeatExchangerTypeEnum.SHELLANDTUBE + + +userdefined = IfcHeatExchangerTypeEnum.USERDEFINED + + +notdefined = IfcHeatExchangerTypeEnum.NOTDEFINED + + +IfcHumidifierTypeEnum = enum_namespace() + + +steaminjection = IfcHumidifierTypeEnum.STEAMINJECTION + + +adiabaticairwasher = IfcHumidifierTypeEnum.ADIABATICAIRWASHER + + +adiabaticpan = IfcHumidifierTypeEnum.ADIABATICPAN + + +adiabaticwettedelement = IfcHumidifierTypeEnum.ADIABATICWETTEDELEMENT + + +adiabaticatomizing = IfcHumidifierTypeEnum.ADIABATICATOMIZING + + +adiabaticultrasonic = IfcHumidifierTypeEnum.ADIABATICULTRASONIC + + +adiabaticrigidmedia = IfcHumidifierTypeEnum.ADIABATICRIGIDMEDIA + + +adiabaticcompressedairnozzle = IfcHumidifierTypeEnum.ADIABATICCOMPRESSEDAIRNOZZLE + + +assistedelectric = IfcHumidifierTypeEnum.ASSISTEDELECTRIC + + +assistednaturalgas = IfcHumidifierTypeEnum.ASSISTEDNATURALGAS + + +assistedpropane = IfcHumidifierTypeEnum.ASSISTEDPROPANE + + +assistedbutane = IfcHumidifierTypeEnum.ASSISTEDBUTANE + + +assistedsteam = IfcHumidifierTypeEnum.ASSISTEDSTEAM + + +userdefined = IfcHumidifierTypeEnum.USERDEFINED + + +notdefined = IfcHumidifierTypeEnum.NOTDEFINED + + +IfcInterceptorTypeEnum = enum_namespace() + + +cyclonic = IfcInterceptorTypeEnum.CYCLONIC + + +grease = IfcInterceptorTypeEnum.GREASE + + +oil = IfcInterceptorTypeEnum.OIL + + +petrol = IfcInterceptorTypeEnum.PETROL + + +userdefined = IfcInterceptorTypeEnum.USERDEFINED + + +notdefined = IfcInterceptorTypeEnum.NOTDEFINED + + +IfcInternalOrExternalEnum = enum_namespace() + + +internal = IfcInternalOrExternalEnum.INTERNAL + + +external = IfcInternalOrExternalEnum.EXTERNAL + + +external_earth = IfcInternalOrExternalEnum.EXTERNAL_EARTH + + +external_water = IfcInternalOrExternalEnum.EXTERNAL_WATER + + +external_fire = IfcInternalOrExternalEnum.EXTERNAL_FIRE + + +notdefined = IfcInternalOrExternalEnum.NOTDEFINED + + +IfcInventoryTypeEnum = enum_namespace() + + +assetinventory = IfcInventoryTypeEnum.ASSETINVENTORY + + +spaceinventory = IfcInventoryTypeEnum.SPACEINVENTORY + + +furnitureinventory = IfcInventoryTypeEnum.FURNITUREINVENTORY + + +userdefined = IfcInventoryTypeEnum.USERDEFINED + + +notdefined = IfcInventoryTypeEnum.NOTDEFINED + + +IfcJunctionBoxTypeEnum = enum_namespace() + + +data = IfcJunctionBoxTypeEnum.DATA + + +power = IfcJunctionBoxTypeEnum.POWER + + +userdefined = IfcJunctionBoxTypeEnum.USERDEFINED + + +notdefined = IfcJunctionBoxTypeEnum.NOTDEFINED + + +IfcKnotType = enum_namespace() + + +uniform_knots = IfcKnotType.UNIFORM_KNOTS + + +quasi_uniform_knots = IfcKnotType.QUASI_UNIFORM_KNOTS + + +piecewise_bezier_knots = IfcKnotType.PIECEWISE_BEZIER_KNOTS + + +unspecified = IfcKnotType.UNSPECIFIED + + +IfcLaborResourceTypeEnum = enum_namespace() + + +administration = IfcLaborResourceTypeEnum.ADMINISTRATION + + +carpentry = IfcLaborResourceTypeEnum.CARPENTRY + + +cleaning = IfcLaborResourceTypeEnum.CLEANING + + +concrete = IfcLaborResourceTypeEnum.CONCRETE + + +drywall = IfcLaborResourceTypeEnum.DRYWALL + + +electric = IfcLaborResourceTypeEnum.ELECTRIC + + +finishing = IfcLaborResourceTypeEnum.FINISHING + + +flooring = IfcLaborResourceTypeEnum.FLOORING + + +general = IfcLaborResourceTypeEnum.GENERAL + + +hvac = IfcLaborResourceTypeEnum.HVAC + + +landscaping = IfcLaborResourceTypeEnum.LANDSCAPING + + +masonry = IfcLaborResourceTypeEnum.MASONRY + + +painting = IfcLaborResourceTypeEnum.PAINTING + + +paving = IfcLaborResourceTypeEnum.PAVING + + +plumbing = IfcLaborResourceTypeEnum.PLUMBING + + +roofing = IfcLaborResourceTypeEnum.ROOFING + + +sitegrading = IfcLaborResourceTypeEnum.SITEGRADING + + +steelwork = IfcLaborResourceTypeEnum.STEELWORK + + +surveying = IfcLaborResourceTypeEnum.SURVEYING + + +userdefined = IfcLaborResourceTypeEnum.USERDEFINED + + +notdefined = IfcLaborResourceTypeEnum.NOTDEFINED + + +IfcLampTypeEnum = enum_namespace() + + +compactfluorescent = IfcLampTypeEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLampTypeEnum.FLUORESCENT + + +halogen = IfcLampTypeEnum.HALOGEN + + +highpressuremercury = IfcLampTypeEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLampTypeEnum.HIGHPRESSURESODIUM + + +led = IfcLampTypeEnum.LED + + +metalhalide = IfcLampTypeEnum.METALHALIDE + + +oled = IfcLampTypeEnum.OLED + + +tungstenfilament = IfcLampTypeEnum.TUNGSTENFILAMENT + + +userdefined = IfcLampTypeEnum.USERDEFINED + + +notdefined = IfcLampTypeEnum.NOTDEFINED + + +IfcLayerSetDirectionEnum = enum_namespace() + + +axis1 = IfcLayerSetDirectionEnum.AXIS1 + + +axis2 = IfcLayerSetDirectionEnum.AXIS2 + + +axis3 = IfcLayerSetDirectionEnum.AXIS3 + + +IfcLightDistributionCurveEnum = enum_namespace() + + +type_a = IfcLightDistributionCurveEnum.TYPE_A + + +type_b = IfcLightDistributionCurveEnum.TYPE_B + + +type_c = IfcLightDistributionCurveEnum.TYPE_C + + +notdefined = IfcLightDistributionCurveEnum.NOTDEFINED + + +IfcLightEmissionSourceEnum = enum_namespace() + + +compactfluorescent = IfcLightEmissionSourceEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLightEmissionSourceEnum.FLUORESCENT + + +highpressuremercury = IfcLightEmissionSourceEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLightEmissionSourceEnum.HIGHPRESSURESODIUM + + +lightemittingdiode = IfcLightEmissionSourceEnum.LIGHTEMITTINGDIODE + + +lowpressuresodium = IfcLightEmissionSourceEnum.LOWPRESSURESODIUM + + +lowvoltagehalogen = IfcLightEmissionSourceEnum.LOWVOLTAGEHALOGEN + + +mainvoltagehalogen = IfcLightEmissionSourceEnum.MAINVOLTAGEHALOGEN + + +metalhalide = IfcLightEmissionSourceEnum.METALHALIDE + + +tungstenfilament = IfcLightEmissionSourceEnum.TUNGSTENFILAMENT + + +notdefined = IfcLightEmissionSourceEnum.NOTDEFINED + + +IfcLightFixtureTypeEnum = enum_namespace() + + +pointsource = IfcLightFixtureTypeEnum.POINTSOURCE + + +directionsource = IfcLightFixtureTypeEnum.DIRECTIONSOURCE + + +securitylighting = IfcLightFixtureTypeEnum.SECURITYLIGHTING + + +userdefined = IfcLightFixtureTypeEnum.USERDEFINED + + +notdefined = IfcLightFixtureTypeEnum.NOTDEFINED + + +IfcLoadGroupTypeEnum = enum_namespace() + + +load_group = IfcLoadGroupTypeEnum.LOAD_GROUP + + +load_case = IfcLoadGroupTypeEnum.LOAD_CASE + + +load_combination = IfcLoadGroupTypeEnum.LOAD_COMBINATION + + +userdefined = IfcLoadGroupTypeEnum.USERDEFINED + + +notdefined = IfcLoadGroupTypeEnum.NOTDEFINED + + +IfcLogicalOperatorEnum = enum_namespace() + + +logicaland = IfcLogicalOperatorEnum.LOGICALAND + + +logicalor = IfcLogicalOperatorEnum.LOGICALOR + + +logicalxor = IfcLogicalOperatorEnum.LOGICALXOR + + +logicalnotand = IfcLogicalOperatorEnum.LOGICALNOTAND + + +logicalnotor = IfcLogicalOperatorEnum.LOGICALNOTOR + + +IfcMechanicalFastenerTypeEnum = enum_namespace() + + +anchorbolt = IfcMechanicalFastenerTypeEnum.ANCHORBOLT + + +bolt = IfcMechanicalFastenerTypeEnum.BOLT + + +dowel = IfcMechanicalFastenerTypeEnum.DOWEL + + +nail = IfcMechanicalFastenerTypeEnum.NAIL + + +nailplate = IfcMechanicalFastenerTypeEnum.NAILPLATE + + +rivet = IfcMechanicalFastenerTypeEnum.RIVET + + +screw = IfcMechanicalFastenerTypeEnum.SCREW + + +shearconnector = IfcMechanicalFastenerTypeEnum.SHEARCONNECTOR + + +staple = IfcMechanicalFastenerTypeEnum.STAPLE + + +studshearconnector = IfcMechanicalFastenerTypeEnum.STUDSHEARCONNECTOR + + +userdefined = IfcMechanicalFastenerTypeEnum.USERDEFINED + + +notdefined = IfcMechanicalFastenerTypeEnum.NOTDEFINED + + +IfcMedicalDeviceTypeEnum = enum_namespace() + + +airstation = IfcMedicalDeviceTypeEnum.AIRSTATION + + +feedairunit = IfcMedicalDeviceTypeEnum.FEEDAIRUNIT + + +oxygengenerator = IfcMedicalDeviceTypeEnum.OXYGENGENERATOR + + +oxygenplant = IfcMedicalDeviceTypeEnum.OXYGENPLANT + + +vacuumstation = IfcMedicalDeviceTypeEnum.VACUUMSTATION + + +userdefined = IfcMedicalDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMedicalDeviceTypeEnum.NOTDEFINED + + +IfcMemberTypeEnum = enum_namespace() + + +brace = IfcMemberTypeEnum.BRACE + + +chord = IfcMemberTypeEnum.CHORD + + +collar = IfcMemberTypeEnum.COLLAR + + +member = IfcMemberTypeEnum.MEMBER + + +mullion = IfcMemberTypeEnum.MULLION + + +plate = IfcMemberTypeEnum.PLATE + + +post = IfcMemberTypeEnum.POST + + +purlin = IfcMemberTypeEnum.PURLIN + + +rafter = IfcMemberTypeEnum.RAFTER + + +stringer = IfcMemberTypeEnum.STRINGER + + +strut = IfcMemberTypeEnum.STRUT + + +stud = IfcMemberTypeEnum.STUD + + +userdefined = IfcMemberTypeEnum.USERDEFINED + + +notdefined = IfcMemberTypeEnum.NOTDEFINED + + +IfcMotorConnectionTypeEnum = enum_namespace() + + +beltdrive = IfcMotorConnectionTypeEnum.BELTDRIVE + + +coupling = IfcMotorConnectionTypeEnum.COUPLING + + +directdrive = IfcMotorConnectionTypeEnum.DIRECTDRIVE + + +userdefined = IfcMotorConnectionTypeEnum.USERDEFINED + + +notdefined = IfcMotorConnectionTypeEnum.NOTDEFINED + + +IfcNullStyle = enum_namespace() + + +null = IfcNullStyle.NULL + + +IfcObjectTypeEnum = enum_namespace() + + +product = IfcObjectTypeEnum.PRODUCT + + +process = IfcObjectTypeEnum.PROCESS + + +control = IfcObjectTypeEnum.CONTROL + + +resource = IfcObjectTypeEnum.RESOURCE + + +actor = IfcObjectTypeEnum.ACTOR + + +group = IfcObjectTypeEnum.GROUP + + +project = IfcObjectTypeEnum.PROJECT + + +notdefined = IfcObjectTypeEnum.NOTDEFINED + + +IfcObjectiveEnum = enum_namespace() + + +codecompliance = IfcObjectiveEnum.CODECOMPLIANCE + + +codewaiver = IfcObjectiveEnum.CODEWAIVER + + +designintent = IfcObjectiveEnum.DESIGNINTENT + + +external = IfcObjectiveEnum.EXTERNAL + + +healthandsafety = IfcObjectiveEnum.HEALTHANDSAFETY + + +mergeconflict = IfcObjectiveEnum.MERGECONFLICT + + +modelview = IfcObjectiveEnum.MODELVIEW + + +parameter = IfcObjectiveEnum.PARAMETER + + +requirement = IfcObjectiveEnum.REQUIREMENT + + +specification = IfcObjectiveEnum.SPECIFICATION + + +triggercondition = IfcObjectiveEnum.TRIGGERCONDITION + + +userdefined = IfcObjectiveEnum.USERDEFINED + + +notdefined = IfcObjectiveEnum.NOTDEFINED + + +IfcOccupantTypeEnum = enum_namespace() + + +assignee = IfcOccupantTypeEnum.ASSIGNEE + + +assignor = IfcOccupantTypeEnum.ASSIGNOR + + +lessee = IfcOccupantTypeEnum.LESSEE + + +lessor = IfcOccupantTypeEnum.LESSOR + + +lettingagent = IfcOccupantTypeEnum.LETTINGAGENT + + +owner = IfcOccupantTypeEnum.OWNER + + +tenant = IfcOccupantTypeEnum.TENANT + + +userdefined = IfcOccupantTypeEnum.USERDEFINED + + +notdefined = IfcOccupantTypeEnum.NOTDEFINED + + +IfcOpeningElementTypeEnum = enum_namespace() + + +opening = IfcOpeningElementTypeEnum.OPENING + + +recess = IfcOpeningElementTypeEnum.RECESS + + +userdefined = IfcOpeningElementTypeEnum.USERDEFINED + + +notdefined = IfcOpeningElementTypeEnum.NOTDEFINED + + +IfcOutletTypeEnum = enum_namespace() + + +audiovisualoutlet = IfcOutletTypeEnum.AUDIOVISUALOUTLET + + +communicationsoutlet = IfcOutletTypeEnum.COMMUNICATIONSOUTLET + + +poweroutlet = IfcOutletTypeEnum.POWEROUTLET + + +dataoutlet = IfcOutletTypeEnum.DATAOUTLET + + +telephoneoutlet = IfcOutletTypeEnum.TELEPHONEOUTLET + + +userdefined = IfcOutletTypeEnum.USERDEFINED + + +notdefined = IfcOutletTypeEnum.NOTDEFINED + + +IfcPerformanceHistoryTypeEnum = enum_namespace() + + +userdefined = IfcPerformanceHistoryTypeEnum.USERDEFINED + + +notdefined = IfcPerformanceHistoryTypeEnum.NOTDEFINED + + +IfcPermeableCoveringOperationEnum = enum_namespace() + + +grill = IfcPermeableCoveringOperationEnum.GRILL + + +louver = IfcPermeableCoveringOperationEnum.LOUVER + + +screen = IfcPermeableCoveringOperationEnum.SCREEN + + +userdefined = IfcPermeableCoveringOperationEnum.USERDEFINED + + +notdefined = IfcPermeableCoveringOperationEnum.NOTDEFINED + + +IfcPermitTypeEnum = enum_namespace() + + +access = IfcPermitTypeEnum.ACCESS + + +building = IfcPermitTypeEnum.BUILDING + + +work = IfcPermitTypeEnum.WORK + + +userdefined = IfcPermitTypeEnum.USERDEFINED + + +notdefined = IfcPermitTypeEnum.NOTDEFINED + + +IfcPhysicalOrVirtualEnum = enum_namespace() + + +physical = IfcPhysicalOrVirtualEnum.PHYSICAL + + +virtual = IfcPhysicalOrVirtualEnum.VIRTUAL + + +notdefined = IfcPhysicalOrVirtualEnum.NOTDEFINED + + +IfcPileConstructionEnum = enum_namespace() + + +cast_in_place = IfcPileConstructionEnum.CAST_IN_PLACE + + +composite = IfcPileConstructionEnum.COMPOSITE + + +precast_concrete = IfcPileConstructionEnum.PRECAST_CONCRETE + + +prefab_steel = IfcPileConstructionEnum.PREFAB_STEEL + + +userdefined = IfcPileConstructionEnum.USERDEFINED + + +notdefined = IfcPileConstructionEnum.NOTDEFINED + + +IfcPileTypeEnum = enum_namespace() + + +bored = IfcPileTypeEnum.BORED + + +driven = IfcPileTypeEnum.DRIVEN + + +jetgrouting = IfcPileTypeEnum.JETGROUTING + + +cohesion = IfcPileTypeEnum.COHESION + + +friction = IfcPileTypeEnum.FRICTION + + +support = IfcPileTypeEnum.SUPPORT + + +userdefined = IfcPileTypeEnum.USERDEFINED + + +notdefined = IfcPileTypeEnum.NOTDEFINED + + +IfcPipeFittingTypeEnum = enum_namespace() + + +bend = IfcPipeFittingTypeEnum.BEND + + +connector = IfcPipeFittingTypeEnum.CONNECTOR + + +entry = IfcPipeFittingTypeEnum.ENTRY + + +exit = IfcPipeFittingTypeEnum.EXIT + + +junction = IfcPipeFittingTypeEnum.JUNCTION + + +obstruction = IfcPipeFittingTypeEnum.OBSTRUCTION + + +transition = IfcPipeFittingTypeEnum.TRANSITION + + +userdefined = IfcPipeFittingTypeEnum.USERDEFINED + + +notdefined = IfcPipeFittingTypeEnum.NOTDEFINED + + +IfcPipeSegmentTypeEnum = enum_namespace() + + +culvert = IfcPipeSegmentTypeEnum.CULVERT + + +flexiblesegment = IfcPipeSegmentTypeEnum.FLEXIBLESEGMENT + + +rigidsegment = IfcPipeSegmentTypeEnum.RIGIDSEGMENT + + +gutter = IfcPipeSegmentTypeEnum.GUTTER + + +spool = IfcPipeSegmentTypeEnum.SPOOL + + +userdefined = IfcPipeSegmentTypeEnum.USERDEFINED + + +notdefined = IfcPipeSegmentTypeEnum.NOTDEFINED + + +IfcPlateTypeEnum = enum_namespace() + + +curtain_panel = IfcPlateTypeEnum.CURTAIN_PANEL + + +sheet = IfcPlateTypeEnum.SHEET + + +userdefined = IfcPlateTypeEnum.USERDEFINED + + +notdefined = IfcPlateTypeEnum.NOTDEFINED + + +IfcPreferredSurfaceCurveRepresentation = enum_namespace() + + +curve3d = IfcPreferredSurfaceCurveRepresentation.CURVE3D + + +pcurve_s1 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S1 + + +pcurve_s2 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S2 + + +IfcProcedureTypeEnum = enum_namespace() + + +advice_caution = IfcProcedureTypeEnum.ADVICE_CAUTION + + +advice_note = IfcProcedureTypeEnum.ADVICE_NOTE + + +advice_warning = IfcProcedureTypeEnum.ADVICE_WARNING + + +calibration = IfcProcedureTypeEnum.CALIBRATION + + +diagnostic = IfcProcedureTypeEnum.DIAGNOSTIC + + +shutdown = IfcProcedureTypeEnum.SHUTDOWN + + +startup = IfcProcedureTypeEnum.STARTUP + + +userdefined = IfcProcedureTypeEnum.USERDEFINED + + +notdefined = IfcProcedureTypeEnum.NOTDEFINED + + +IfcProfileTypeEnum = enum_namespace() + + +curve = IfcProfileTypeEnum.CURVE + + +area = IfcProfileTypeEnum.AREA + + +IfcProjectOrderTypeEnum = enum_namespace() + + +changeorder = IfcProjectOrderTypeEnum.CHANGEORDER + + +maintenanceworkorder = IfcProjectOrderTypeEnum.MAINTENANCEWORKORDER + + +moveorder = IfcProjectOrderTypeEnum.MOVEORDER + + +purchaseorder = IfcProjectOrderTypeEnum.PURCHASEORDER + + +workorder = IfcProjectOrderTypeEnum.WORKORDER + + +userdefined = IfcProjectOrderTypeEnum.USERDEFINED + + +notdefined = IfcProjectOrderTypeEnum.NOTDEFINED + + +IfcProjectedOrTrueLengthEnum = enum_namespace() + + +projected_length = IfcProjectedOrTrueLengthEnum.PROJECTED_LENGTH + + +true_length = IfcProjectedOrTrueLengthEnum.TRUE_LENGTH + + +IfcProjectionElementTypeEnum = enum_namespace() + + +userdefined = IfcProjectionElementTypeEnum.USERDEFINED + + +notdefined = IfcProjectionElementTypeEnum.NOTDEFINED + + +IfcPropertySetTemplateTypeEnum = enum_namespace() + + +pset_typedrivenonly = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENONLY + + +pset_typedrivenoverride = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENOVERRIDE + + +pset_occurrencedriven = IfcPropertySetTemplateTypeEnum.PSET_OCCURRENCEDRIVEN + + +pset_performancedriven = IfcPropertySetTemplateTypeEnum.PSET_PERFORMANCEDRIVEN + + +qto_typedrivenonly = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENONLY + + +qto_typedrivenoverride = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENOVERRIDE + + +qto_occurrencedriven = IfcPropertySetTemplateTypeEnum.QTO_OCCURRENCEDRIVEN + + +notdefined = IfcPropertySetTemplateTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTrippingUnitTypeEnum = enum_namespace() + + +electronic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTRONIC + + +electromagnetic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTROMAGNETIC + + +residualcurrent = IfcProtectiveDeviceTrippingUnitTypeEnum.RESIDUALCURRENT + + +thermal = IfcProtectiveDeviceTrippingUnitTypeEnum.THERMAL + + +userdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTypeEnum = enum_namespace() + + +circuitbreaker = IfcProtectiveDeviceTypeEnum.CIRCUITBREAKER + + +earthleakagecircuitbreaker = IfcProtectiveDeviceTypeEnum.EARTHLEAKAGECIRCUITBREAKER + + +earthingswitch = IfcProtectiveDeviceTypeEnum.EARTHINGSWITCH + + +fusedisconnector = IfcProtectiveDeviceTypeEnum.FUSEDISCONNECTOR + + +residualcurrentcircuitbreaker = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTCIRCUITBREAKER + + +residualcurrentswitch = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTSWITCH + + +varistor = IfcProtectiveDeviceTypeEnum.VARISTOR + + +userdefined = IfcProtectiveDeviceTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTypeEnum.NOTDEFINED + + +IfcPumpTypeEnum = enum_namespace() + + +circulator = IfcPumpTypeEnum.CIRCULATOR + + +endsuction = IfcPumpTypeEnum.ENDSUCTION + + +splitcase = IfcPumpTypeEnum.SPLITCASE + + +submersiblepump = IfcPumpTypeEnum.SUBMERSIBLEPUMP + + +sumppump = IfcPumpTypeEnum.SUMPPUMP + + +verticalinline = IfcPumpTypeEnum.VERTICALINLINE + + +verticalturbine = IfcPumpTypeEnum.VERTICALTURBINE + + +userdefined = IfcPumpTypeEnum.USERDEFINED + + +notdefined = IfcPumpTypeEnum.NOTDEFINED + + +IfcRailingTypeEnum = enum_namespace() + + +handrail = IfcRailingTypeEnum.HANDRAIL + + +guardrail = IfcRailingTypeEnum.GUARDRAIL + + +balustrade = IfcRailingTypeEnum.BALUSTRADE + + +userdefined = IfcRailingTypeEnum.USERDEFINED + + +notdefined = IfcRailingTypeEnum.NOTDEFINED + + +IfcRampFlightTypeEnum = enum_namespace() + + +straight = IfcRampFlightTypeEnum.STRAIGHT + + +spiral = IfcRampFlightTypeEnum.SPIRAL + + +userdefined = IfcRampFlightTypeEnum.USERDEFINED + + +notdefined = IfcRampFlightTypeEnum.NOTDEFINED + + +IfcRampTypeEnum = enum_namespace() + + +straight_run_ramp = IfcRampTypeEnum.STRAIGHT_RUN_RAMP + + +two_straight_run_ramp = IfcRampTypeEnum.TWO_STRAIGHT_RUN_RAMP + + +quarter_turn_ramp = IfcRampTypeEnum.QUARTER_TURN_RAMP + + +two_quarter_turn_ramp = IfcRampTypeEnum.TWO_QUARTER_TURN_RAMP + + +half_turn_ramp = IfcRampTypeEnum.HALF_TURN_RAMP + + +spiral_ramp = IfcRampTypeEnum.SPIRAL_RAMP + + +userdefined = IfcRampTypeEnum.USERDEFINED + + +notdefined = IfcRampTypeEnum.NOTDEFINED + + +IfcRecurrenceTypeEnum = enum_namespace() + + +daily = IfcRecurrenceTypeEnum.DAILY + + +weekly = IfcRecurrenceTypeEnum.WEEKLY + + +monthly_by_day_of_month = IfcRecurrenceTypeEnum.MONTHLY_BY_DAY_OF_MONTH + + +monthly_by_position = IfcRecurrenceTypeEnum.MONTHLY_BY_POSITION + + +by_day_count = IfcRecurrenceTypeEnum.BY_DAY_COUNT + + +by_weekday_count = IfcRecurrenceTypeEnum.BY_WEEKDAY_COUNT + + +yearly_by_day_of_month = IfcRecurrenceTypeEnum.YEARLY_BY_DAY_OF_MONTH + + +yearly_by_position = IfcRecurrenceTypeEnum.YEARLY_BY_POSITION + + +IfcReferentTypeEnum = enum_namespace() + + +kilopoint = IfcReferentTypeEnum.KILOPOINT + + +milepoint = IfcReferentTypeEnum.MILEPOINT + + +station = IfcReferentTypeEnum.STATION + + +userdefined = IfcReferentTypeEnum.USERDEFINED + + +notdefined = IfcReferentTypeEnum.NOTDEFINED + + +IfcReflectanceMethodEnum = enum_namespace() + + +blinn = IfcReflectanceMethodEnum.BLINN + + +flat = IfcReflectanceMethodEnum.FLAT + + +glass = IfcReflectanceMethodEnum.GLASS + + +matt = IfcReflectanceMethodEnum.MATT + + +metal = IfcReflectanceMethodEnum.METAL + + +mirror = IfcReflectanceMethodEnum.MIRROR + + +phong = IfcReflectanceMethodEnum.PHONG + + +plastic = IfcReflectanceMethodEnum.PLASTIC + + +strauss = IfcReflectanceMethodEnum.STRAUSS + + +notdefined = IfcReflectanceMethodEnum.NOTDEFINED + + +IfcReinforcingBarRoleEnum = enum_namespace() + + +main = IfcReinforcingBarRoleEnum.MAIN + + +shear = IfcReinforcingBarRoleEnum.SHEAR + + +ligature = IfcReinforcingBarRoleEnum.LIGATURE + + +stud = IfcReinforcingBarRoleEnum.STUD + + +punching = IfcReinforcingBarRoleEnum.PUNCHING + + +edge = IfcReinforcingBarRoleEnum.EDGE + + +ring = IfcReinforcingBarRoleEnum.RING + + +anchoring = IfcReinforcingBarRoleEnum.ANCHORING + + +userdefined = IfcReinforcingBarRoleEnum.USERDEFINED + + +notdefined = IfcReinforcingBarRoleEnum.NOTDEFINED + + +IfcReinforcingBarSurfaceEnum = enum_namespace() + + +plain = IfcReinforcingBarSurfaceEnum.PLAIN + + +textured = IfcReinforcingBarSurfaceEnum.TEXTURED + + +IfcReinforcingBarTypeEnum = enum_namespace() + + +anchoring = IfcReinforcingBarTypeEnum.ANCHORING + + +edge = IfcReinforcingBarTypeEnum.EDGE + + +ligature = IfcReinforcingBarTypeEnum.LIGATURE + + +main = IfcReinforcingBarTypeEnum.MAIN + + +punching = IfcReinforcingBarTypeEnum.PUNCHING + + +ring = IfcReinforcingBarTypeEnum.RING + + +shear = IfcReinforcingBarTypeEnum.SHEAR + + +stud = IfcReinforcingBarTypeEnum.STUD + + +userdefined = IfcReinforcingBarTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingBarTypeEnum.NOTDEFINED + + +IfcReinforcingMeshTypeEnum = enum_namespace() + + +userdefined = IfcReinforcingMeshTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingMeshTypeEnum.NOTDEFINED + + +IfcRoleEnum = enum_namespace() + + +supplier = IfcRoleEnum.SUPPLIER + + +manufacturer = IfcRoleEnum.MANUFACTURER + + +contractor = IfcRoleEnum.CONTRACTOR + + +subcontractor = IfcRoleEnum.SUBCONTRACTOR + + +architect = IfcRoleEnum.ARCHITECT + + +structuralengineer = IfcRoleEnum.STRUCTURALENGINEER + + +costengineer = IfcRoleEnum.COSTENGINEER + + +client = IfcRoleEnum.CLIENT + + +buildingowner = IfcRoleEnum.BUILDINGOWNER + + +buildingoperator = IfcRoleEnum.BUILDINGOPERATOR + + +mechanicalengineer = IfcRoleEnum.MECHANICALENGINEER + + +electricalengineer = IfcRoleEnum.ELECTRICALENGINEER + + +projectmanager = IfcRoleEnum.PROJECTMANAGER + + +facilitiesmanager = IfcRoleEnum.FACILITIESMANAGER + + +civilengineer = IfcRoleEnum.CIVILENGINEER + + +commissioningengineer = IfcRoleEnum.COMMISSIONINGENGINEER + + +engineer = IfcRoleEnum.ENGINEER + + +owner = IfcRoleEnum.OWNER + + +consultant = IfcRoleEnum.CONSULTANT + + +constructionmanager = IfcRoleEnum.CONSTRUCTIONMANAGER + + +fieldconstructionmanager = IfcRoleEnum.FIELDCONSTRUCTIONMANAGER + + +reseller = IfcRoleEnum.RESELLER + + +userdefined = IfcRoleEnum.USERDEFINED + + +IfcRoofTypeEnum = enum_namespace() + + +flat_roof = IfcRoofTypeEnum.FLAT_ROOF + + +shed_roof = IfcRoofTypeEnum.SHED_ROOF + + +gable_roof = IfcRoofTypeEnum.GABLE_ROOF + + +hip_roof = IfcRoofTypeEnum.HIP_ROOF + + +hipped_gable_roof = IfcRoofTypeEnum.HIPPED_GABLE_ROOF + + +gambrel_roof = IfcRoofTypeEnum.GAMBREL_ROOF + + +mansard_roof = IfcRoofTypeEnum.MANSARD_ROOF + + +barrel_roof = IfcRoofTypeEnum.BARREL_ROOF + + +rainbow_roof = IfcRoofTypeEnum.RAINBOW_ROOF + + +butterfly_roof = IfcRoofTypeEnum.BUTTERFLY_ROOF + + +pavilion_roof = IfcRoofTypeEnum.PAVILION_ROOF + + +dome_roof = IfcRoofTypeEnum.DOME_ROOF + + +freeform = IfcRoofTypeEnum.FREEFORM + + +userdefined = IfcRoofTypeEnum.USERDEFINED + + +notdefined = IfcRoofTypeEnum.NOTDEFINED + + +IfcSIPrefix = enum_namespace() + + +exa = IfcSIPrefix.EXA + + +peta = IfcSIPrefix.PETA + + +tera = IfcSIPrefix.TERA + + +giga = IfcSIPrefix.GIGA + + +mega = IfcSIPrefix.MEGA + + +kilo = IfcSIPrefix.KILO + + +hecto = IfcSIPrefix.HECTO + + +deca = IfcSIPrefix.DECA + + +deci = IfcSIPrefix.DECI + + +centi = IfcSIPrefix.CENTI + + +milli = IfcSIPrefix.MILLI + + +micro = IfcSIPrefix.MICRO + + +nano = IfcSIPrefix.NANO + + +pico = IfcSIPrefix.PICO + + +femto = IfcSIPrefix.FEMTO + + +atto = IfcSIPrefix.ATTO + + +IfcSIUnitName = enum_namespace() + + +ampere = IfcSIUnitName.AMPERE + + +becquerel = IfcSIUnitName.BECQUEREL + + +candela = IfcSIUnitName.CANDELA + + +coulomb = IfcSIUnitName.COULOMB + + +cubic_metre = IfcSIUnitName.CUBIC_METRE + + +degree_celsius = IfcSIUnitName.DEGREE_CELSIUS + + +farad = IfcSIUnitName.FARAD + + +gram = IfcSIUnitName.GRAM + + +gray = IfcSIUnitName.GRAY + + +henry = IfcSIUnitName.HENRY + + +hertz = IfcSIUnitName.HERTZ + + +joule = IfcSIUnitName.JOULE + + +kelvin = IfcSIUnitName.KELVIN + + +lumen = IfcSIUnitName.LUMEN + + +lux = IfcSIUnitName.LUX + + +metre = IfcSIUnitName.METRE + + +mole = IfcSIUnitName.MOLE + + +newton = IfcSIUnitName.NEWTON + + +ohm = IfcSIUnitName.OHM + + +pascal = IfcSIUnitName.PASCAL + + +radian = IfcSIUnitName.RADIAN + + +second = IfcSIUnitName.SECOND + + +siemens = IfcSIUnitName.SIEMENS + + +sievert = IfcSIUnitName.SIEVERT + + +square_metre = IfcSIUnitName.SQUARE_METRE + + +steradian = IfcSIUnitName.STERADIAN + + +tesla = IfcSIUnitName.TESLA + + +volt = IfcSIUnitName.VOLT + + +watt = IfcSIUnitName.WATT + + +weber = IfcSIUnitName.WEBER + + +IfcSanitaryTerminalTypeEnum = enum_namespace() + + +bath = IfcSanitaryTerminalTypeEnum.BATH + + +bidet = IfcSanitaryTerminalTypeEnum.BIDET + + +cistern = IfcSanitaryTerminalTypeEnum.CISTERN + + +shower = IfcSanitaryTerminalTypeEnum.SHOWER + + +sink = IfcSanitaryTerminalTypeEnum.SINK + + +sanitaryfountain = IfcSanitaryTerminalTypeEnum.SANITARYFOUNTAIN + + +toiletpan = IfcSanitaryTerminalTypeEnum.TOILETPAN + + +urinal = IfcSanitaryTerminalTypeEnum.URINAL + + +washhandbasin = IfcSanitaryTerminalTypeEnum.WASHHANDBASIN + + +wcseat = IfcSanitaryTerminalTypeEnum.WCSEAT + + +userdefined = IfcSanitaryTerminalTypeEnum.USERDEFINED + + +notdefined = IfcSanitaryTerminalTypeEnum.NOTDEFINED + + +IfcSectionTypeEnum = enum_namespace() + + +uniform = IfcSectionTypeEnum.UNIFORM + + +tapered = IfcSectionTypeEnum.TAPERED + + +IfcSensorTypeEnum = enum_namespace() + + +cosensor = IfcSensorTypeEnum.COSENSOR + + +co2sensor = IfcSensorTypeEnum.CO2SENSOR + + +conductancesensor = IfcSensorTypeEnum.CONDUCTANCESENSOR + + +contactsensor = IfcSensorTypeEnum.CONTACTSENSOR + + +firesensor = IfcSensorTypeEnum.FIRESENSOR + + +flowsensor = IfcSensorTypeEnum.FLOWSENSOR + + +frostsensor = IfcSensorTypeEnum.FROSTSENSOR + + +gassensor = IfcSensorTypeEnum.GASSENSOR + + +heatsensor = IfcSensorTypeEnum.HEATSENSOR + + +humiditysensor = IfcSensorTypeEnum.HUMIDITYSENSOR + + +identifiersensor = IfcSensorTypeEnum.IDENTIFIERSENSOR + + +ionconcentrationsensor = IfcSensorTypeEnum.IONCONCENTRATIONSENSOR + + +levelsensor = IfcSensorTypeEnum.LEVELSENSOR + + +lightsensor = IfcSensorTypeEnum.LIGHTSENSOR + + +moisturesensor = IfcSensorTypeEnum.MOISTURESENSOR + + +movementsensor = IfcSensorTypeEnum.MOVEMENTSENSOR + + +phsensor = IfcSensorTypeEnum.PHSENSOR + + +pressuresensor = IfcSensorTypeEnum.PRESSURESENSOR + + +radiationsensor = IfcSensorTypeEnum.RADIATIONSENSOR + + +radioactivitysensor = IfcSensorTypeEnum.RADIOACTIVITYSENSOR + + +smokesensor = IfcSensorTypeEnum.SMOKESENSOR + + +soundsensor = IfcSensorTypeEnum.SOUNDSENSOR + + +temperaturesensor = IfcSensorTypeEnum.TEMPERATURESENSOR + + +windsensor = IfcSensorTypeEnum.WINDSENSOR + + +userdefined = IfcSensorTypeEnum.USERDEFINED + + +notdefined = IfcSensorTypeEnum.NOTDEFINED + + +IfcSequenceEnum = enum_namespace() + + +start_start = IfcSequenceEnum.START_START + + +start_finish = IfcSequenceEnum.START_FINISH + + +finish_start = IfcSequenceEnum.FINISH_START + + +finish_finish = IfcSequenceEnum.FINISH_FINISH + + +userdefined = IfcSequenceEnum.USERDEFINED + + +notdefined = IfcSequenceEnum.NOTDEFINED + + +IfcShadingDeviceTypeEnum = enum_namespace() + + +jalousie = IfcShadingDeviceTypeEnum.JALOUSIE + + +shutter = IfcShadingDeviceTypeEnum.SHUTTER + + +awning = IfcShadingDeviceTypeEnum.AWNING + + +userdefined = IfcShadingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcShadingDeviceTypeEnum.NOTDEFINED + + +IfcSimplePropertyTemplateTypeEnum = enum_namespace() + + +p_singlevalue = IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE + + +p_enumeratedvalue = IfcSimplePropertyTemplateTypeEnum.P_ENUMERATEDVALUE + + +p_boundedvalue = IfcSimplePropertyTemplateTypeEnum.P_BOUNDEDVALUE + + +p_listvalue = IfcSimplePropertyTemplateTypeEnum.P_LISTVALUE + + +p_tablevalue = IfcSimplePropertyTemplateTypeEnum.P_TABLEVALUE + + +p_referencevalue = IfcSimplePropertyTemplateTypeEnum.P_REFERENCEVALUE + + +q_length = IfcSimplePropertyTemplateTypeEnum.Q_LENGTH + + +q_area = IfcSimplePropertyTemplateTypeEnum.Q_AREA + + +q_volume = IfcSimplePropertyTemplateTypeEnum.Q_VOLUME + + +q_count = IfcSimplePropertyTemplateTypeEnum.Q_COUNT + + +q_weight = IfcSimplePropertyTemplateTypeEnum.Q_WEIGHT + + +q_time = IfcSimplePropertyTemplateTypeEnum.Q_TIME + + +IfcSlabTypeEnum = enum_namespace() + + +floor = IfcSlabTypeEnum.FLOOR + + +roof = IfcSlabTypeEnum.ROOF + + +landing = IfcSlabTypeEnum.LANDING + + +baseslab = IfcSlabTypeEnum.BASESLAB + + +userdefined = IfcSlabTypeEnum.USERDEFINED + + +notdefined = IfcSlabTypeEnum.NOTDEFINED + + +IfcSolarDeviceTypeEnum = enum_namespace() + + +solarcollector = IfcSolarDeviceTypeEnum.SOLARCOLLECTOR + + +solarpanel = IfcSolarDeviceTypeEnum.SOLARPANEL + + +userdefined = IfcSolarDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSolarDeviceTypeEnum.NOTDEFINED + + +IfcSpaceHeaterTypeEnum = enum_namespace() + + +convector = IfcSpaceHeaterTypeEnum.CONVECTOR + + +radiator = IfcSpaceHeaterTypeEnum.RADIATOR + + +userdefined = IfcSpaceHeaterTypeEnum.USERDEFINED + + +notdefined = IfcSpaceHeaterTypeEnum.NOTDEFINED + + +IfcSpaceTypeEnum = enum_namespace() + + +space = IfcSpaceTypeEnum.SPACE + + +parking = IfcSpaceTypeEnum.PARKING + + +gfa = IfcSpaceTypeEnum.GFA + + +internal = IfcSpaceTypeEnum.INTERNAL + + +external = IfcSpaceTypeEnum.EXTERNAL + + +userdefined = IfcSpaceTypeEnum.USERDEFINED + + +notdefined = IfcSpaceTypeEnum.NOTDEFINED + + +IfcSpatialZoneTypeEnum = enum_namespace() + + +construction = IfcSpatialZoneTypeEnum.CONSTRUCTION + + +firesafety = IfcSpatialZoneTypeEnum.FIRESAFETY + + +lighting = IfcSpatialZoneTypeEnum.LIGHTING + + +occupancy = IfcSpatialZoneTypeEnum.OCCUPANCY + + +security = IfcSpatialZoneTypeEnum.SECURITY + + +thermal = IfcSpatialZoneTypeEnum.THERMAL + + +transport = IfcSpatialZoneTypeEnum.TRANSPORT + + +ventilation = IfcSpatialZoneTypeEnum.VENTILATION + + +userdefined = IfcSpatialZoneTypeEnum.USERDEFINED + + +notdefined = IfcSpatialZoneTypeEnum.NOTDEFINED + + +IfcStackTerminalTypeEnum = enum_namespace() + + +birdcage = IfcStackTerminalTypeEnum.BIRDCAGE + + +cowl = IfcStackTerminalTypeEnum.COWL + + +rainwaterhopper = IfcStackTerminalTypeEnum.RAINWATERHOPPER + + +userdefined = IfcStackTerminalTypeEnum.USERDEFINED + + +notdefined = IfcStackTerminalTypeEnum.NOTDEFINED + + +IfcStairFlightTypeEnum = enum_namespace() + + +straight = IfcStairFlightTypeEnum.STRAIGHT + + +winder = IfcStairFlightTypeEnum.WINDER + + +spiral = IfcStairFlightTypeEnum.SPIRAL + + +curved = IfcStairFlightTypeEnum.CURVED + + +freeform = IfcStairFlightTypeEnum.FREEFORM + + +userdefined = IfcStairFlightTypeEnum.USERDEFINED + + +notdefined = IfcStairFlightTypeEnum.NOTDEFINED + + +IfcStairTypeEnum = enum_namespace() + + +straight_run_stair = IfcStairTypeEnum.STRAIGHT_RUN_STAIR + + +two_straight_run_stair = IfcStairTypeEnum.TWO_STRAIGHT_RUN_STAIR + + +quarter_winding_stair = IfcStairTypeEnum.QUARTER_WINDING_STAIR + + +quarter_turn_stair = IfcStairTypeEnum.QUARTER_TURN_STAIR + + +half_winding_stair = IfcStairTypeEnum.HALF_WINDING_STAIR + + +half_turn_stair = IfcStairTypeEnum.HALF_TURN_STAIR + + +two_quarter_winding_stair = IfcStairTypeEnum.TWO_QUARTER_WINDING_STAIR + + +two_quarter_turn_stair = IfcStairTypeEnum.TWO_QUARTER_TURN_STAIR + + +three_quarter_winding_stair = IfcStairTypeEnum.THREE_QUARTER_WINDING_STAIR + + +three_quarter_turn_stair = IfcStairTypeEnum.THREE_QUARTER_TURN_STAIR + + +spiral_stair = IfcStairTypeEnum.SPIRAL_STAIR + + +double_return_stair = IfcStairTypeEnum.DOUBLE_RETURN_STAIR + + +curved_run_stair = IfcStairTypeEnum.CURVED_RUN_STAIR + + +two_curved_run_stair = IfcStairTypeEnum.TWO_CURVED_RUN_STAIR + + +userdefined = IfcStairTypeEnum.USERDEFINED + + +notdefined = IfcStairTypeEnum.NOTDEFINED + + +IfcStateEnum = enum_namespace() + + +readwrite = IfcStateEnum.READWRITE + + +readonly = IfcStateEnum.READONLY + + +locked = IfcStateEnum.LOCKED + + +readwritelocked = IfcStateEnum.READWRITELOCKED + + +readonlylocked = IfcStateEnum.READONLYLOCKED + + +IfcStructuralCurveActivityTypeEnum = enum_namespace() + + +const = IfcStructuralCurveActivityTypeEnum.CONST + + +linear = IfcStructuralCurveActivityTypeEnum.LINEAR + + +polygonal = IfcStructuralCurveActivityTypeEnum.POLYGONAL + + +equidistant = IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + +sinus = IfcStructuralCurveActivityTypeEnum.SINUS + + +parabola = IfcStructuralCurveActivityTypeEnum.PARABOLA + + +discrete = IfcStructuralCurveActivityTypeEnum.DISCRETE + + +userdefined = IfcStructuralCurveActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveActivityTypeEnum.NOTDEFINED + + +IfcStructuralCurveMemberTypeEnum = enum_namespace() + + +rigid_joined_member = IfcStructuralCurveMemberTypeEnum.RIGID_JOINED_MEMBER + + +pin_joined_member = IfcStructuralCurveMemberTypeEnum.PIN_JOINED_MEMBER + + +cable = IfcStructuralCurveMemberTypeEnum.CABLE + + +tension_member = IfcStructuralCurveMemberTypeEnum.TENSION_MEMBER + + +compression_member = IfcStructuralCurveMemberTypeEnum.COMPRESSION_MEMBER + + +userdefined = IfcStructuralCurveMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveMemberTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceActivityTypeEnum = enum_namespace() + + +const = IfcStructuralSurfaceActivityTypeEnum.CONST + + +bilinear = IfcStructuralSurfaceActivityTypeEnum.BILINEAR + + +discrete = IfcStructuralSurfaceActivityTypeEnum.DISCRETE + + +isocontour = IfcStructuralSurfaceActivityTypeEnum.ISOCONTOUR + + +userdefined = IfcStructuralSurfaceActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceActivityTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceMemberTypeEnum = enum_namespace() + + +bending_element = IfcStructuralSurfaceMemberTypeEnum.BENDING_ELEMENT + + +membrane_element = IfcStructuralSurfaceMemberTypeEnum.MEMBRANE_ELEMENT + + +shell = IfcStructuralSurfaceMemberTypeEnum.SHELL + + +userdefined = IfcStructuralSurfaceMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceMemberTypeEnum.NOTDEFINED + + +IfcSubContractResourceTypeEnum = enum_namespace() + + +purchase = IfcSubContractResourceTypeEnum.PURCHASE + + +work = IfcSubContractResourceTypeEnum.WORK + + +userdefined = IfcSubContractResourceTypeEnum.USERDEFINED + + +notdefined = IfcSubContractResourceTypeEnum.NOTDEFINED + + +IfcSurfaceFeatureTypeEnum = enum_namespace() + + +mark = IfcSurfaceFeatureTypeEnum.MARK + + +tag = IfcSurfaceFeatureTypeEnum.TAG + + +treatment = IfcSurfaceFeatureTypeEnum.TREATMENT + + +userdefined = IfcSurfaceFeatureTypeEnum.USERDEFINED + + +notdefined = IfcSurfaceFeatureTypeEnum.NOTDEFINED + + +IfcSurfaceSide = enum_namespace() + + +positive = IfcSurfaceSide.POSITIVE + + +negative = IfcSurfaceSide.NEGATIVE + + +both = IfcSurfaceSide.BOTH + + +IfcSwitchingDeviceTypeEnum = enum_namespace() + + +contactor = IfcSwitchingDeviceTypeEnum.CONTACTOR + + +dimmerswitch = IfcSwitchingDeviceTypeEnum.DIMMERSWITCH + + +emergencystop = IfcSwitchingDeviceTypeEnum.EMERGENCYSTOP + + +keypad = IfcSwitchingDeviceTypeEnum.KEYPAD + + +momentaryswitch = IfcSwitchingDeviceTypeEnum.MOMENTARYSWITCH + + +selectorswitch = IfcSwitchingDeviceTypeEnum.SELECTORSWITCH + + +starter = IfcSwitchingDeviceTypeEnum.STARTER + + +switchdisconnector = IfcSwitchingDeviceTypeEnum.SWITCHDISCONNECTOR + + +toggleswitch = IfcSwitchingDeviceTypeEnum.TOGGLESWITCH + + +userdefined = IfcSwitchingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSwitchingDeviceTypeEnum.NOTDEFINED + + +IfcSystemFurnitureElementTypeEnum = enum_namespace() + + +panel = IfcSystemFurnitureElementTypeEnum.PANEL + + +worksurface = IfcSystemFurnitureElementTypeEnum.WORKSURFACE + + +userdefined = IfcSystemFurnitureElementTypeEnum.USERDEFINED + + +notdefined = IfcSystemFurnitureElementTypeEnum.NOTDEFINED + + +IfcTankTypeEnum = enum_namespace() + + +basin = IfcTankTypeEnum.BASIN + + +breakpressure = IfcTankTypeEnum.BREAKPRESSURE + + +expansion = IfcTankTypeEnum.EXPANSION + + +feedandexpansion = IfcTankTypeEnum.FEEDANDEXPANSION + + +pressurevessel = IfcTankTypeEnum.PRESSUREVESSEL + + +storage = IfcTankTypeEnum.STORAGE + + +vessel = IfcTankTypeEnum.VESSEL + + +userdefined = IfcTankTypeEnum.USERDEFINED + + +notdefined = IfcTankTypeEnum.NOTDEFINED + + +IfcTaskDurationEnum = enum_namespace() + + +elapsedtime = IfcTaskDurationEnum.ELAPSEDTIME + + +worktime = IfcTaskDurationEnum.WORKTIME + + +notdefined = IfcTaskDurationEnum.NOTDEFINED + + +IfcTaskTypeEnum = enum_namespace() + + +attendance = IfcTaskTypeEnum.ATTENDANCE + + +construction = IfcTaskTypeEnum.CONSTRUCTION + + +demolition = IfcTaskTypeEnum.DEMOLITION + + +dismantle = IfcTaskTypeEnum.DISMANTLE + + +disposal = IfcTaskTypeEnum.DISPOSAL + + +installation = IfcTaskTypeEnum.INSTALLATION + + +logistic = IfcTaskTypeEnum.LOGISTIC + + +maintenance = IfcTaskTypeEnum.MAINTENANCE + + +move = IfcTaskTypeEnum.MOVE + + +operation = IfcTaskTypeEnum.OPERATION + + +removal = IfcTaskTypeEnum.REMOVAL + + +renovation = IfcTaskTypeEnum.RENOVATION + + +userdefined = IfcTaskTypeEnum.USERDEFINED + + +notdefined = IfcTaskTypeEnum.NOTDEFINED + + +IfcTendonAnchorTypeEnum = enum_namespace() + + +coupler = IfcTendonAnchorTypeEnum.COUPLER + + +fixed_end = IfcTendonAnchorTypeEnum.FIXED_END + + +tensioning_end = IfcTendonAnchorTypeEnum.TENSIONING_END + + +userdefined = IfcTendonAnchorTypeEnum.USERDEFINED + + +notdefined = IfcTendonAnchorTypeEnum.NOTDEFINED + + +IfcTendonTypeEnum = enum_namespace() + + +bar = IfcTendonTypeEnum.BAR + + +coated = IfcTendonTypeEnum.COATED + + +strand = IfcTendonTypeEnum.STRAND + + +wire = IfcTendonTypeEnum.WIRE + + +userdefined = IfcTendonTypeEnum.USERDEFINED + + +notdefined = IfcTendonTypeEnum.NOTDEFINED + + +IfcTextPath = enum_namespace() + + +left = IfcTextPath.LEFT + + +right = IfcTextPath.RIGHT + + +up = IfcTextPath.UP + + +down = IfcTextPath.DOWN + + +IfcTimeSeriesDataTypeEnum = enum_namespace() + + +continuous = IfcTimeSeriesDataTypeEnum.CONTINUOUS + + +discrete = IfcTimeSeriesDataTypeEnum.DISCRETE + + +discretebinary = IfcTimeSeriesDataTypeEnum.DISCRETEBINARY + + +piecewisebinary = IfcTimeSeriesDataTypeEnum.PIECEWISEBINARY + + +piecewiseconstant = IfcTimeSeriesDataTypeEnum.PIECEWISECONSTANT + + +piecewisecontinuous = IfcTimeSeriesDataTypeEnum.PIECEWISECONTINUOUS + + +notdefined = IfcTimeSeriesDataTypeEnum.NOTDEFINED + + +IfcTransformerTypeEnum = enum_namespace() + + +current = IfcTransformerTypeEnum.CURRENT + + +frequency = IfcTransformerTypeEnum.FREQUENCY + + +inverter = IfcTransformerTypeEnum.INVERTER + + +rectifier = IfcTransformerTypeEnum.RECTIFIER + + +voltage = IfcTransformerTypeEnum.VOLTAGE + + +userdefined = IfcTransformerTypeEnum.USERDEFINED + + +notdefined = IfcTransformerTypeEnum.NOTDEFINED + + +IfcTransitionCode = enum_namespace() + + +discontinuous = IfcTransitionCode.DISCONTINUOUS + + +continuous = IfcTransitionCode.CONTINUOUS + + +contsamegradient = IfcTransitionCode.CONTSAMEGRADIENT + + +contsamegradientsamecurvature = IfcTransitionCode.CONTSAMEGRADIENTSAMECURVATURE + + +IfcTransitionCurveType = enum_namespace() + + +biquadraticparabola = IfcTransitionCurveType.BIQUADRATICPARABOLA + + +blosscurve = IfcTransitionCurveType.BLOSSCURVE + + +clothoidcurve = IfcTransitionCurveType.CLOTHOIDCURVE + + +cosinecurve = IfcTransitionCurveType.COSINECURVE + + +cubicparabola = IfcTransitionCurveType.CUBICPARABOLA + + +sinecurve = IfcTransitionCurveType.SINECURVE + + +IfcTransportElementTypeEnum = enum_namespace() + + +elevator = IfcTransportElementTypeEnum.ELEVATOR + + +escalator = IfcTransportElementTypeEnum.ESCALATOR + + +movingwalkway = IfcTransportElementTypeEnum.MOVINGWALKWAY + + +craneway = IfcTransportElementTypeEnum.CRANEWAY + + +liftinggear = IfcTransportElementTypeEnum.LIFTINGGEAR + + +userdefined = IfcTransportElementTypeEnum.USERDEFINED + + +notdefined = IfcTransportElementTypeEnum.NOTDEFINED + + +IfcTrimmingPreference = enum_namespace() + + +cartesian = IfcTrimmingPreference.CARTESIAN + + +parameter = IfcTrimmingPreference.PARAMETER + + +unspecified = IfcTrimmingPreference.UNSPECIFIED + + +IfcTubeBundleTypeEnum = enum_namespace() + + +finned = IfcTubeBundleTypeEnum.FINNED + + +userdefined = IfcTubeBundleTypeEnum.USERDEFINED + + +notdefined = IfcTubeBundleTypeEnum.NOTDEFINED + + +IfcUnitEnum = enum_namespace() + + +absorbeddoseunit = IfcUnitEnum.ABSORBEDDOSEUNIT + + +amountofsubstanceunit = IfcUnitEnum.AMOUNTOFSUBSTANCEUNIT + + +areaunit = IfcUnitEnum.AREAUNIT + + +doseequivalentunit = IfcUnitEnum.DOSEEQUIVALENTUNIT + + +electriccapacitanceunit = IfcUnitEnum.ELECTRICCAPACITANCEUNIT + + +electricchargeunit = IfcUnitEnum.ELECTRICCHARGEUNIT + + +electricconductanceunit = IfcUnitEnum.ELECTRICCONDUCTANCEUNIT + + +electriccurrentunit = IfcUnitEnum.ELECTRICCURRENTUNIT + + +electricresistanceunit = IfcUnitEnum.ELECTRICRESISTANCEUNIT + + +electricvoltageunit = IfcUnitEnum.ELECTRICVOLTAGEUNIT + + +energyunit = IfcUnitEnum.ENERGYUNIT + + +forceunit = IfcUnitEnum.FORCEUNIT + + +frequencyunit = IfcUnitEnum.FREQUENCYUNIT + + +illuminanceunit = IfcUnitEnum.ILLUMINANCEUNIT + + +inductanceunit = IfcUnitEnum.INDUCTANCEUNIT + + +lengthunit = IfcUnitEnum.LENGTHUNIT + + +luminousfluxunit = IfcUnitEnum.LUMINOUSFLUXUNIT + + +luminousintensityunit = IfcUnitEnum.LUMINOUSINTENSITYUNIT + + +magneticfluxdensityunit = IfcUnitEnum.MAGNETICFLUXDENSITYUNIT + + +magneticfluxunit = IfcUnitEnum.MAGNETICFLUXUNIT + + +massunit = IfcUnitEnum.MASSUNIT + + +planeangleunit = IfcUnitEnum.PLANEANGLEUNIT + + +powerunit = IfcUnitEnum.POWERUNIT + + +pressureunit = IfcUnitEnum.PRESSUREUNIT + + +radioactivityunit = IfcUnitEnum.RADIOACTIVITYUNIT + + +solidangleunit = IfcUnitEnum.SOLIDANGLEUNIT + + +thermodynamictemperatureunit = IfcUnitEnum.THERMODYNAMICTEMPERATUREUNIT + + +timeunit = IfcUnitEnum.TIMEUNIT + + +volumeunit = IfcUnitEnum.VOLUMEUNIT + + +userdefined = IfcUnitEnum.USERDEFINED + + +IfcUnitaryControlElementTypeEnum = enum_namespace() + + +alarmpanel = IfcUnitaryControlElementTypeEnum.ALARMPANEL + + +controlpanel = IfcUnitaryControlElementTypeEnum.CONTROLPANEL + + +gasdetectionpanel = IfcUnitaryControlElementTypeEnum.GASDETECTIONPANEL + + +indicatorpanel = IfcUnitaryControlElementTypeEnum.INDICATORPANEL + + +mimicpanel = IfcUnitaryControlElementTypeEnum.MIMICPANEL + + +humidistat = IfcUnitaryControlElementTypeEnum.HUMIDISTAT + + +thermostat = IfcUnitaryControlElementTypeEnum.THERMOSTAT + + +weatherstation = IfcUnitaryControlElementTypeEnum.WEATHERSTATION + + +userdefined = IfcUnitaryControlElementTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryControlElementTypeEnum.NOTDEFINED + + +IfcUnitaryEquipmentTypeEnum = enum_namespace() + + +airhandler = IfcUnitaryEquipmentTypeEnum.AIRHANDLER + + +airconditioningunit = IfcUnitaryEquipmentTypeEnum.AIRCONDITIONINGUNIT + + +dehumidifier = IfcUnitaryEquipmentTypeEnum.DEHUMIDIFIER + + +splitsystem = IfcUnitaryEquipmentTypeEnum.SPLITSYSTEM + + +rooftopunit = IfcUnitaryEquipmentTypeEnum.ROOFTOPUNIT + + +userdefined = IfcUnitaryEquipmentTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryEquipmentTypeEnum.NOTDEFINED + + +IfcValveTypeEnum = enum_namespace() + + +airrelease = IfcValveTypeEnum.AIRRELEASE + + +antivacuum = IfcValveTypeEnum.ANTIVACUUM + + +changeover = IfcValveTypeEnum.CHANGEOVER + + +check = IfcValveTypeEnum.CHECK + + +commissioning = IfcValveTypeEnum.COMMISSIONING + + +diverting = IfcValveTypeEnum.DIVERTING + + +drawoffcock = IfcValveTypeEnum.DRAWOFFCOCK + + +doublecheck = IfcValveTypeEnum.DOUBLECHECK + + +doubleregulating = IfcValveTypeEnum.DOUBLEREGULATING + + +faucet = IfcValveTypeEnum.FAUCET + + +flushing = IfcValveTypeEnum.FLUSHING + + +gascock = IfcValveTypeEnum.GASCOCK + + +gastap = IfcValveTypeEnum.GASTAP + + +isolating = IfcValveTypeEnum.ISOLATING + + +mixing = IfcValveTypeEnum.MIXING + + +pressurereducing = IfcValveTypeEnum.PRESSUREREDUCING + + +pressurerelief = IfcValveTypeEnum.PRESSURERELIEF + + +regulating = IfcValveTypeEnum.REGULATING + + +safetycutoff = IfcValveTypeEnum.SAFETYCUTOFF + + +steamtrap = IfcValveTypeEnum.STEAMTRAP + + +stopcock = IfcValveTypeEnum.STOPCOCK + + +userdefined = IfcValveTypeEnum.USERDEFINED + + +notdefined = IfcValveTypeEnum.NOTDEFINED + + +IfcVibrationIsolatorTypeEnum = enum_namespace() + + +compression = IfcVibrationIsolatorTypeEnum.COMPRESSION + + +spring = IfcVibrationIsolatorTypeEnum.SPRING + + +userdefined = IfcVibrationIsolatorTypeEnum.USERDEFINED + + +notdefined = IfcVibrationIsolatorTypeEnum.NOTDEFINED + + +IfcVoidingFeatureTypeEnum = enum_namespace() + + +cutout = IfcVoidingFeatureTypeEnum.CUTOUT + + +notch = IfcVoidingFeatureTypeEnum.NOTCH + + +hole = IfcVoidingFeatureTypeEnum.HOLE + + +miter = IfcVoidingFeatureTypeEnum.MITER + + +chamfer = IfcVoidingFeatureTypeEnum.CHAMFER + + +edge = IfcVoidingFeatureTypeEnum.EDGE + + +userdefined = IfcVoidingFeatureTypeEnum.USERDEFINED + + +notdefined = IfcVoidingFeatureTypeEnum.NOTDEFINED + + +IfcWallTypeEnum = enum_namespace() + + +movable = IfcWallTypeEnum.MOVABLE + + +parapet = IfcWallTypeEnum.PARAPET + + +partitioning = IfcWallTypeEnum.PARTITIONING + + +plumbingwall = IfcWallTypeEnum.PLUMBINGWALL + + +shear = IfcWallTypeEnum.SHEAR + + +solidwall = IfcWallTypeEnum.SOLIDWALL + + +standard = IfcWallTypeEnum.STANDARD + + +polygonal = IfcWallTypeEnum.POLYGONAL + + +elementedwall = IfcWallTypeEnum.ELEMENTEDWALL + + +userdefined = IfcWallTypeEnum.USERDEFINED + + +notdefined = IfcWallTypeEnum.NOTDEFINED + + +IfcWasteTerminalTypeEnum = enum_namespace() + + +floortrap = IfcWasteTerminalTypeEnum.FLOORTRAP + + +floorwaste = IfcWasteTerminalTypeEnum.FLOORWASTE + + +gullysump = IfcWasteTerminalTypeEnum.GULLYSUMP + + +gullytrap = IfcWasteTerminalTypeEnum.GULLYTRAP + + +roofdrain = IfcWasteTerminalTypeEnum.ROOFDRAIN + + +wastedisposalunit = IfcWasteTerminalTypeEnum.WASTEDISPOSALUNIT + + +wastetrap = IfcWasteTerminalTypeEnum.WASTETRAP + + +userdefined = IfcWasteTerminalTypeEnum.USERDEFINED + + +notdefined = IfcWasteTerminalTypeEnum.NOTDEFINED + + +IfcWindowPanelOperationEnum = enum_namespace() + + +sidehungrighthand = IfcWindowPanelOperationEnum.SIDEHUNGRIGHTHAND + + +sidehunglefthand = IfcWindowPanelOperationEnum.SIDEHUNGLEFTHAND + + +tiltandturnrighthand = IfcWindowPanelOperationEnum.TILTANDTURNRIGHTHAND + + +tiltandturnlefthand = IfcWindowPanelOperationEnum.TILTANDTURNLEFTHAND + + +tophung = IfcWindowPanelOperationEnum.TOPHUNG + + +bottomhung = IfcWindowPanelOperationEnum.BOTTOMHUNG + + +pivothorizontal = IfcWindowPanelOperationEnum.PIVOTHORIZONTAL + + +pivotvertical = IfcWindowPanelOperationEnum.PIVOTVERTICAL + + +slidinghorizontal = IfcWindowPanelOperationEnum.SLIDINGHORIZONTAL + + +slidingvertical = IfcWindowPanelOperationEnum.SLIDINGVERTICAL + + +removablecasement = IfcWindowPanelOperationEnum.REMOVABLECASEMENT + + +fixedcasement = IfcWindowPanelOperationEnum.FIXEDCASEMENT + + +otheroperation = IfcWindowPanelOperationEnum.OTHEROPERATION + + +notdefined = IfcWindowPanelOperationEnum.NOTDEFINED + + +IfcWindowPanelPositionEnum = enum_namespace() + + +left = IfcWindowPanelPositionEnum.LEFT + + +middle = IfcWindowPanelPositionEnum.MIDDLE + + +right = IfcWindowPanelPositionEnum.RIGHT + + +bottom = IfcWindowPanelPositionEnum.BOTTOM + + +top = IfcWindowPanelPositionEnum.TOP + + +notdefined = IfcWindowPanelPositionEnum.NOTDEFINED + + +IfcWindowStyleConstructionEnum = enum_namespace() + + +aluminium = IfcWindowStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcWindowStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcWindowStyleConstructionEnum.STEEL + + +wood = IfcWindowStyleConstructionEnum.WOOD + + +aluminium_wood = IfcWindowStyleConstructionEnum.ALUMINIUM_WOOD + + +plastic = IfcWindowStyleConstructionEnum.PLASTIC + + +other_construction = IfcWindowStyleConstructionEnum.OTHER_CONSTRUCTION + + +notdefined = IfcWindowStyleConstructionEnum.NOTDEFINED + + +IfcWindowStyleOperationEnum = enum_namespace() + + +single_panel = IfcWindowStyleOperationEnum.SINGLE_PANEL + + +double_panel_vertical = IfcWindowStyleOperationEnum.DOUBLE_PANEL_VERTICAL + + +double_panel_horizontal = IfcWindowStyleOperationEnum.DOUBLE_PANEL_HORIZONTAL + + +triple_panel_vertical = IfcWindowStyleOperationEnum.TRIPLE_PANEL_VERTICAL + + +triple_panel_bottom = IfcWindowStyleOperationEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_top = IfcWindowStyleOperationEnum.TRIPLE_PANEL_TOP + + +triple_panel_left = IfcWindowStyleOperationEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowStyleOperationEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_horizontal = IfcWindowStyleOperationEnum.TRIPLE_PANEL_HORIZONTAL + + +userdefined = IfcWindowStyleOperationEnum.USERDEFINED + + +notdefined = IfcWindowStyleOperationEnum.NOTDEFINED + + +IfcWindowTypeEnum = enum_namespace() + + +window = IfcWindowTypeEnum.WINDOW + + +skylight = IfcWindowTypeEnum.SKYLIGHT + + +lightdome = IfcWindowTypeEnum.LIGHTDOME + + +userdefined = IfcWindowTypeEnum.USERDEFINED + + +notdefined = IfcWindowTypeEnum.NOTDEFINED + + +IfcWindowTypePartitioningEnum = enum_namespace() + + +single_panel = IfcWindowTypePartitioningEnum.SINGLE_PANEL + + +double_panel_vertical = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_VERTICAL + + +double_panel_horizontal = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_HORIZONTAL + + +triple_panel_vertical = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_VERTICAL + + +triple_panel_bottom = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_top = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_TOP + + +triple_panel_left = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_horizontal = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_HORIZONTAL + + +userdefined = IfcWindowTypePartitioningEnum.USERDEFINED + + +notdefined = IfcWindowTypePartitioningEnum.NOTDEFINED + + +IfcWorkCalendarTypeEnum = enum_namespace() + + +firstshift = IfcWorkCalendarTypeEnum.FIRSTSHIFT + + +secondshift = IfcWorkCalendarTypeEnum.SECONDSHIFT + + +thirdshift = IfcWorkCalendarTypeEnum.THIRDSHIFT + + +userdefined = IfcWorkCalendarTypeEnum.USERDEFINED + + +notdefined = IfcWorkCalendarTypeEnum.NOTDEFINED + + +IfcWorkPlanTypeEnum = enum_namespace() + + +actual = IfcWorkPlanTypeEnum.ACTUAL + + +baseline = IfcWorkPlanTypeEnum.BASELINE + + +planned = IfcWorkPlanTypeEnum.PLANNED + + +userdefined = IfcWorkPlanTypeEnum.USERDEFINED + + +notdefined = IfcWorkPlanTypeEnum.NOTDEFINED + + +IfcWorkScheduleTypeEnum = enum_namespace() + + +actual = IfcWorkScheduleTypeEnum.ACTUAL + + +baseline = IfcWorkScheduleTypeEnum.BASELINE + + +planned = IfcWorkScheduleTypeEnum.PLANNED + + +userdefined = IfcWorkScheduleTypeEnum.USERDEFINED + + +notdefined = IfcWorkScheduleTypeEnum.NOTDEFINED + + +def IfcActionRequest(*args, **kwargs): return ifcopenshell.create_entity('IfcActionRequest', 'IFC4X1', *args, **kwargs) + + +def IfcActor(*args, **kwargs): return ifcopenshell.create_entity('IfcActor', 'IFC4X1', *args, **kwargs) + + +def IfcActorRole(*args, **kwargs): return ifcopenshell.create_entity('IfcActorRole', 'IFC4X1', *args, **kwargs) + + +def IfcActuator(*args, **kwargs): return ifcopenshell.create_entity('IfcActuator', 'IFC4X1', *args, **kwargs) + + +def IfcActuatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcActuatorType', 'IFC4X1', *args, **kwargs) + + +def IfcAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcAddress', 'IFC4X1', *args, **kwargs) + + +def IfcAdvancedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrep', 'IFC4X1', *args, **kwargs) + + +def IfcAdvancedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrepWithVoids', 'IFC4X1', *args, **kwargs) + + +def IfcAdvancedFace(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedFace', 'IFC4X1', *args, **kwargs) + + +def IfcAirTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminal', 'IFC4X1', *args, **kwargs) + + +def IfcAirTerminalBox(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBox', 'IFC4X1', *args, **kwargs) + + +def IfcAirTerminalBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBoxType', 'IFC4X1', *args, **kwargs) + + +def IfcAirTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalType', 'IFC4X1', *args, **kwargs) + + +def IfcAirToAirHeatRecovery(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecovery', 'IFC4X1', *args, **kwargs) + + +def IfcAirToAirHeatRecoveryType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecoveryType', 'IFC4X1', *args, **kwargs) + + +def IfcAlarm(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarm', 'IFC4X1', *args, **kwargs) + + +def IfcAlarmType(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarmType', 'IFC4X1', *args, **kwargs) + + +def IfcAlignment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment', 'IFC4X1', *args, **kwargs) + + +def IfcAlignment2DHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DHorizontal', 'IFC4X1', *args, **kwargs) + + +def IfcAlignment2DHorizontalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DHorizontalSegment', 'IFC4X1', *args, **kwargs) + + +def IfcAlignment2DSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DSegment', 'IFC4X1', *args, **kwargs) + + +def IfcAlignment2DVerSegCircularArc(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerSegCircularArc', 'IFC4X1', *args, **kwargs) + + +def IfcAlignment2DVerSegLine(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerSegLine', 'IFC4X1', *args, **kwargs) + + +def IfcAlignment2DVerSegParabolicArc(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerSegParabolicArc', 'IFC4X1', *args, **kwargs) + + +def IfcAlignment2DVertical(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVertical', 'IFC4X1', *args, **kwargs) + + +def IfcAlignment2DVerticalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerticalSegment', 'IFC4X1', *args, **kwargs) + + +def IfcAlignmentCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCurve', 'IFC4X1', *args, **kwargs) + + +def IfcAnnotation(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotation', 'IFC4X1', *args, **kwargs) + + +def IfcAnnotationFillArea(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationFillArea', 'IFC4X1', *args, **kwargs) + + +def IfcApplication(*args, **kwargs): return ifcopenshell.create_entity('IfcApplication', 'IFC4X1', *args, **kwargs) + + +def IfcAppliedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcAppliedValue', 'IFC4X1', *args, **kwargs) + + +def IfcApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcApproval', 'IFC4X1', *args, **kwargs) + + +def IfcApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcApprovalRelationship', 'IFC4X1', *args, **kwargs) + + +def IfcArbitraryClosedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryClosedProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcArbitraryOpenProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryOpenProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcArbitraryProfileDefWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryProfileDefWithVoids', 'IFC4X1', *args, **kwargs) + + +def IfcAsset(*args, **kwargs): return ifcopenshell.create_entity('IfcAsset', 'IFC4X1', *args, **kwargs) + + +def IfcAsymmetricIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcAsymmetricIShapeProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcAudioVisualAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualAppliance', 'IFC4X1', *args, **kwargs) + + +def IfcAudioVisualApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualApplianceType', 'IFC4X1', *args, **kwargs) + + +def IfcAxis1Placement(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis1Placement', 'IFC4X1', *args, **kwargs) + + +def IfcAxis2Placement2D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement2D', 'IFC4X1', *args, **kwargs) + + +def IfcAxis2Placement3D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement3D', 'IFC4X1', *args, **kwargs) + + +def IfcBSplineCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurve', 'IFC4X1', *args, **kwargs) + + +def IfcBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurveWithKnots', 'IFC4X1', *args, **kwargs) + + +def IfcBSplineSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurface', 'IFC4X1', *args, **kwargs) + + +def IfcBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurfaceWithKnots', 'IFC4X1', *args, **kwargs) + + +def IfcBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcBeam', 'IFC4X1', *args, **kwargs) + + +def IfcBeamStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamStandardCase', 'IFC4X1', *args, **kwargs) + + +def IfcBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamType', 'IFC4X1', *args, **kwargs) + + +def IfcBlobTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcBlobTexture', 'IFC4X1', *args, **kwargs) + + +def IfcBlock(*args, **kwargs): return ifcopenshell.create_entity('IfcBlock', 'IFC4X1', *args, **kwargs) + + +def IfcBoiler(*args, **kwargs): return ifcopenshell.create_entity('IfcBoiler', 'IFC4X1', *args, **kwargs) + + +def IfcBoilerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBoilerType', 'IFC4X1', *args, **kwargs) + + +def IfcBooleanClippingResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanClippingResult', 'IFC4X1', *args, **kwargs) + + +def IfcBooleanResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanResult', 'IFC4X1', *args, **kwargs) + + +def IfcBoundaryCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCondition', 'IFC4X1', *args, **kwargs) + + +def IfcBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCurve', 'IFC4X1', *args, **kwargs) + + +def IfcBoundaryEdgeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryEdgeCondition', 'IFC4X1', *args, **kwargs) + + +def IfcBoundaryFaceCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryFaceCondition', 'IFC4X1', *args, **kwargs) + + +def IfcBoundaryNodeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeCondition', 'IFC4X1', *args, **kwargs) + + +def IfcBoundaryNodeConditionWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeConditionWarping', 'IFC4X1', *args, **kwargs) + + +def IfcBoundedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedCurve', 'IFC4X1', *args, **kwargs) + + +def IfcBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedSurface', 'IFC4X1', *args, **kwargs) + + +def IfcBoundingBox(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundingBox', 'IFC4X1', *args, **kwargs) + + +def IfcBoxedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcBoxedHalfSpace', 'IFC4X1', *args, **kwargs) + + +def IfcBuilding(*args, **kwargs): return ifcopenshell.create_entity('IfcBuilding', 'IFC4X1', *args, **kwargs) + + +def IfcBuildingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElement', 'IFC4X1', *args, **kwargs) + + +def IfcBuildingElementPart(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPart', 'IFC4X1', *args, **kwargs) + + +def IfcBuildingElementPartType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPartType', 'IFC4X1', *args, **kwargs) + + +def IfcBuildingElementProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxy', 'IFC4X1', *args, **kwargs) + + +def IfcBuildingElementProxyType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxyType', 'IFC4X1', *args, **kwargs) + + +def IfcBuildingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementType', 'IFC4X1', *args, **kwargs) + + +def IfcBuildingStorey(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingStorey', 'IFC4X1', *args, **kwargs) + + +def IfcBuildingSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingSystem', 'IFC4X1', *args, **kwargs) + + +def IfcBurner(*args, **kwargs): return ifcopenshell.create_entity('IfcBurner', 'IFC4X1', *args, **kwargs) + + +def IfcBurnerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBurnerType', 'IFC4X1', *args, **kwargs) + + +def IfcCShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCShapeProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcCableCarrierFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFitting', 'IFC4X1', *args, **kwargs) + + +def IfcCableCarrierFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFittingType', 'IFC4X1', *args, **kwargs) + + +def IfcCableCarrierSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegment', 'IFC4X1', *args, **kwargs) + + +def IfcCableCarrierSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegmentType', 'IFC4X1', *args, **kwargs) + + +def IfcCableFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFitting', 'IFC4X1', *args, **kwargs) + + +def IfcCableFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFittingType', 'IFC4X1', *args, **kwargs) + + +def IfcCableSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegment', 'IFC4X1', *args, **kwargs) + + +def IfcCableSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegmentType', 'IFC4X1', *args, **kwargs) + + +def IfcCartesianPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPoint', 'IFC4X1', *args, **kwargs) + + +def IfcCartesianPointList(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList', 'IFC4X1', *args, **kwargs) + + +def IfcCartesianPointList2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList2D', 'IFC4X1', *args, **kwargs) + + +def IfcCartesianPointList3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList3D', 'IFC4X1', *args, **kwargs) + + +def IfcCartesianTransformationOperator(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator', 'IFC4X1', *args, **kwargs) + + +def IfcCartesianTransformationOperator2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2D', 'IFC4X1', *args, **kwargs) + + +def IfcCartesianTransformationOperator2DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2DnonUniform', 'IFC4X1', *args, **kwargs) + + +def IfcCartesianTransformationOperator3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3D', 'IFC4X1', *args, **kwargs) + + +def IfcCartesianTransformationOperator3DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3DnonUniform', 'IFC4X1', *args, **kwargs) + + +def IfcCenterLineProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCenterLineProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcChiller(*args, **kwargs): return ifcopenshell.create_entity('IfcChiller', 'IFC4X1', *args, **kwargs) + + +def IfcChillerType(*args, **kwargs): return ifcopenshell.create_entity('IfcChillerType', 'IFC4X1', *args, **kwargs) + + +def IfcChimney(*args, **kwargs): return ifcopenshell.create_entity('IfcChimney', 'IFC4X1', *args, **kwargs) + + +def IfcChimneyType(*args, **kwargs): return ifcopenshell.create_entity('IfcChimneyType', 'IFC4X1', *args, **kwargs) + + +def IfcCircle(*args, **kwargs): return ifcopenshell.create_entity('IfcCircle', 'IFC4X1', *args, **kwargs) + + +def IfcCircleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleHollowProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcCircleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcCircularArcSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCircularArcSegment2D', 'IFC4X1', *args, **kwargs) + + +def IfcCivilElement(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElement', 'IFC4X1', *args, **kwargs) + + +def IfcCivilElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElementType', 'IFC4X1', *args, **kwargs) + + +def IfcClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcClassification', 'IFC4X1', *args, **kwargs) + + +def IfcClassificationReference(*args, **kwargs): return ifcopenshell.create_entity('IfcClassificationReference', 'IFC4X1', *args, **kwargs) + + +def IfcClosedShell(*args, **kwargs): return ifcopenshell.create_entity('IfcClosedShell', 'IFC4X1', *args, **kwargs) + + +def IfcCoil(*args, **kwargs): return ifcopenshell.create_entity('IfcCoil', 'IFC4X1', *args, **kwargs) + + +def IfcCoilType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoilType', 'IFC4X1', *args, **kwargs) + + +def IfcColourRgb(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgb', 'IFC4X1', *args, **kwargs) + + +def IfcColourRgbList(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgbList', 'IFC4X1', *args, **kwargs) + + +def IfcColourSpecification(*args, **kwargs): return ifcopenshell.create_entity('IfcColourSpecification', 'IFC4X1', *args, **kwargs) + + +def IfcColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcColumn', 'IFC4X1', *args, **kwargs) + + +def IfcColumnStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnStandardCase', 'IFC4X1', *args, **kwargs) + + +def IfcColumnType(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnType', 'IFC4X1', *args, **kwargs) + + +def IfcCommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsAppliance', 'IFC4X1', *args, **kwargs) + + +def IfcCommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsApplianceType', 'IFC4X1', *args, **kwargs) + + +def IfcComplexProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexProperty', 'IFC4X1', *args, **kwargs) + + +def IfcComplexPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexPropertyTemplate', 'IFC4X1', *args, **kwargs) + + +def IfcCompositeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurve', 'IFC4X1', *args, **kwargs) + + +def IfcCompositeCurveOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveOnSurface', 'IFC4X1', *args, **kwargs) + + +def IfcCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveSegment', 'IFC4X1', *args, **kwargs) + + +def IfcCompositeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcCompressor(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressor', 'IFC4X1', *args, **kwargs) + + +def IfcCompressorType(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressorType', 'IFC4X1', *args, **kwargs) + + +def IfcCondenser(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenser', 'IFC4X1', *args, **kwargs) + + +def IfcCondenserType(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenserType', 'IFC4X1', *args, **kwargs) + + +def IfcConic(*args, **kwargs): return ifcopenshell.create_entity('IfcConic', 'IFC4X1', *args, **kwargs) + + +def IfcConnectedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectedFaceSet', 'IFC4X1', *args, **kwargs) + + +def IfcConnectionCurveGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionCurveGeometry', 'IFC4X1', *args, **kwargs) + + +def IfcConnectionGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionGeometry', 'IFC4X1', *args, **kwargs) + + +def IfcConnectionPointEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointEccentricity', 'IFC4X1', *args, **kwargs) + + +def IfcConnectionPointGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointGeometry', 'IFC4X1', *args, **kwargs) + + +def IfcConnectionSurfaceGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionSurfaceGeometry', 'IFC4X1', *args, **kwargs) + + +def IfcConnectionVolumeGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionVolumeGeometry', 'IFC4X1', *args, **kwargs) + + +def IfcConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcConstraint', 'IFC4X1', *args, **kwargs) + + +def IfcConstructionEquipmentResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResource', 'IFC4X1', *args, **kwargs) + + +def IfcConstructionEquipmentResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResourceType', 'IFC4X1', *args, **kwargs) + + +def IfcConstructionMaterialResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResource', 'IFC4X1', *args, **kwargs) + + +def IfcConstructionMaterialResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResourceType', 'IFC4X1', *args, **kwargs) + + +def IfcConstructionProductResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResource', 'IFC4X1', *args, **kwargs) + + +def IfcConstructionProductResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResourceType', 'IFC4X1', *args, **kwargs) + + +def IfcConstructionResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResource', 'IFC4X1', *args, **kwargs) + + +def IfcConstructionResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResourceType', 'IFC4X1', *args, **kwargs) + + +def IfcContext(*args, **kwargs): return ifcopenshell.create_entity('IfcContext', 'IFC4X1', *args, **kwargs) + + +def IfcContextDependentUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcContextDependentUnit', 'IFC4X1', *args, **kwargs) + + +def IfcControl(*args, **kwargs): return ifcopenshell.create_entity('IfcControl', 'IFC4X1', *args, **kwargs) + + +def IfcController(*args, **kwargs): return ifcopenshell.create_entity('IfcController', 'IFC4X1', *args, **kwargs) + + +def IfcControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcControllerType', 'IFC4X1', *args, **kwargs) + + +def IfcConversionBasedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnit', 'IFC4X1', *args, **kwargs) + + +def IfcConversionBasedUnitWithOffset(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnitWithOffset', 'IFC4X1', *args, **kwargs) + + +def IfcCooledBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeam', 'IFC4X1', *args, **kwargs) + + +def IfcCooledBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeamType', 'IFC4X1', *args, **kwargs) + + +def IfcCoolingTower(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTower', 'IFC4X1', *args, **kwargs) + + +def IfcCoolingTowerType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTowerType', 'IFC4X1', *args, **kwargs) + + +def IfcCoordinateOperation(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateOperation', 'IFC4X1', *args, **kwargs) + + +def IfcCoordinateReferenceSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateReferenceSystem', 'IFC4X1', *args, **kwargs) + + +def IfcCostItem(*args, **kwargs): return ifcopenshell.create_entity('IfcCostItem', 'IFC4X1', *args, **kwargs) + + +def IfcCostSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcCostSchedule', 'IFC4X1', *args, **kwargs) + + +def IfcCostValue(*args, **kwargs): return ifcopenshell.create_entity('IfcCostValue', 'IFC4X1', *args, **kwargs) + + +def IfcCovering(*args, **kwargs): return ifcopenshell.create_entity('IfcCovering', 'IFC4X1', *args, **kwargs) + + +def IfcCoveringType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoveringType', 'IFC4X1', *args, **kwargs) + + +def IfcCrewResource(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResource', 'IFC4X1', *args, **kwargs) + + +def IfcCrewResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResourceType', 'IFC4X1', *args, **kwargs) + + +def IfcCsgPrimitive3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgPrimitive3D', 'IFC4X1', *args, **kwargs) + + +def IfcCsgSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgSolid', 'IFC4X1', *args, **kwargs) + + +def IfcCurrencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcCurrencyRelationship', 'IFC4X1', *args, **kwargs) + + +def IfcCurtainWall(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWall', 'IFC4X1', *args, **kwargs) + + +def IfcCurtainWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWallType', 'IFC4X1', *args, **kwargs) + + +def IfcCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCurve', 'IFC4X1', *args, **kwargs) + + +def IfcCurveBoundedPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedPlane', 'IFC4X1', *args, **kwargs) + + +def IfcCurveBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedSurface', 'IFC4X1', *args, **kwargs) + + +def IfcCurveSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveSegment2D', 'IFC4X1', *args, **kwargs) + + +def IfcCurveStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyle', 'IFC4X1', *args, **kwargs) + + +def IfcCurveStyleFont(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFont', 'IFC4X1', *args, **kwargs) + + +def IfcCurveStyleFontAndScaling(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontAndScaling', 'IFC4X1', *args, **kwargs) + + +def IfcCurveStyleFontPattern(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontPattern', 'IFC4X1', *args, **kwargs) + + +def IfcCylindricalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCylindricalSurface', 'IFC4X1', *args, **kwargs) + + +def IfcDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcDamper', 'IFC4X1', *args, **kwargs) + + +def IfcDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcDamperType', 'IFC4X1', *args, **kwargs) + + +def IfcDerivedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcDerivedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnit', 'IFC4X1', *args, **kwargs) + + +def IfcDerivedUnitElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnitElement', 'IFC4X1', *args, **kwargs) + + +def IfcDimensionalExponents(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionalExponents', 'IFC4X1', *args, **kwargs) + + +def IfcDirection(*args, **kwargs): return ifcopenshell.create_entity('IfcDirection', 'IFC4X1', *args, **kwargs) + + +def IfcDiscreteAccessory(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessory', 'IFC4X1', *args, **kwargs) + + +def IfcDiscreteAccessoryType(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessoryType', 'IFC4X1', *args, **kwargs) + + +def IfcDistanceExpression(*args, **kwargs): return ifcopenshell.create_entity('IfcDistanceExpression', 'IFC4X1', *args, **kwargs) + + +def IfcDistributionChamberElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElement', 'IFC4X1', *args, **kwargs) + + +def IfcDistributionChamberElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElementType', 'IFC4X1', *args, **kwargs) + + +def IfcDistributionCircuit(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionCircuit', 'IFC4X1', *args, **kwargs) + + +def IfcDistributionControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElement', 'IFC4X1', *args, **kwargs) + + +def IfcDistributionControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElementType', 'IFC4X1', *args, **kwargs) + + +def IfcDistributionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElement', 'IFC4X1', *args, **kwargs) + + +def IfcDistributionElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElementType', 'IFC4X1', *args, **kwargs) + + +def IfcDistributionFlowElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElement', 'IFC4X1', *args, **kwargs) + + +def IfcDistributionFlowElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElementType', 'IFC4X1', *args, **kwargs) + + +def IfcDistributionPort(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionPort', 'IFC4X1', *args, **kwargs) + + +def IfcDistributionSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionSystem', 'IFC4X1', *args, **kwargs) + + +def IfcDocumentInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformation', 'IFC4X1', *args, **kwargs) + + +def IfcDocumentInformationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformationRelationship', 'IFC4X1', *args, **kwargs) + + +def IfcDocumentReference(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentReference', 'IFC4X1', *args, **kwargs) + + +def IfcDoor(*args, **kwargs): return ifcopenshell.create_entity('IfcDoor', 'IFC4X1', *args, **kwargs) + + +def IfcDoorLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorLiningProperties', 'IFC4X1', *args, **kwargs) + + +def IfcDoorPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorPanelProperties', 'IFC4X1', *args, **kwargs) + + +def IfcDoorStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorStandardCase', 'IFC4X1', *args, **kwargs) + + +def IfcDoorStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorStyle', 'IFC4X1', *args, **kwargs) + + +def IfcDoorType(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorType', 'IFC4X1', *args, **kwargs) + + +def IfcDraughtingPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedColour', 'IFC4X1', *args, **kwargs) + + +def IfcDraughtingPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedCurveFont', 'IFC4X1', *args, **kwargs) + + +def IfcDuctFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFitting', 'IFC4X1', *args, **kwargs) + + +def IfcDuctFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFittingType', 'IFC4X1', *args, **kwargs) + + +def IfcDuctSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegment', 'IFC4X1', *args, **kwargs) + + +def IfcDuctSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegmentType', 'IFC4X1', *args, **kwargs) + + +def IfcDuctSilencer(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencer', 'IFC4X1', *args, **kwargs) + + +def IfcDuctSilencerType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencerType', 'IFC4X1', *args, **kwargs) + + +def IfcEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcEdge', 'IFC4X1', *args, **kwargs) + + +def IfcEdgeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeCurve', 'IFC4X1', *args, **kwargs) + + +def IfcEdgeLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeLoop', 'IFC4X1', *args, **kwargs) + + +def IfcElectricAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricAppliance', 'IFC4X1', *args, **kwargs) + + +def IfcElectricApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricApplianceType', 'IFC4X1', *args, **kwargs) + + +def IfcElectricDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoard', 'IFC4X1', *args, **kwargs) + + +def IfcElectricDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoardType', 'IFC4X1', *args, **kwargs) + + +def IfcElectricFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDevice', 'IFC4X1', *args, **kwargs) + + +def IfcElectricFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDeviceType', 'IFC4X1', *args, **kwargs) + + +def IfcElectricGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGenerator', 'IFC4X1', *args, **kwargs) + + +def IfcElectricGeneratorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGeneratorType', 'IFC4X1', *args, **kwargs) + + +def IfcElectricMotor(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotor', 'IFC4X1', *args, **kwargs) + + +def IfcElectricMotorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotorType', 'IFC4X1', *args, **kwargs) + + +def IfcElectricTimeControl(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControl', 'IFC4X1', *args, **kwargs) + + +def IfcElectricTimeControlType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControlType', 'IFC4X1', *args, **kwargs) + + +def IfcElement(*args, **kwargs): return ifcopenshell.create_entity('IfcElement', 'IFC4X1', *args, **kwargs) + + +def IfcElementAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssembly', 'IFC4X1', *args, **kwargs) + + +def IfcElementAssemblyType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssemblyType', 'IFC4X1', *args, **kwargs) + + +def IfcElementComponent(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponent', 'IFC4X1', *args, **kwargs) + + +def IfcElementComponentType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponentType', 'IFC4X1', *args, **kwargs) + + +def IfcElementQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcElementQuantity', 'IFC4X1', *args, **kwargs) + + +def IfcElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementType', 'IFC4X1', *args, **kwargs) + + +def IfcElementarySurface(*args, **kwargs): return ifcopenshell.create_entity('IfcElementarySurface', 'IFC4X1', *args, **kwargs) + + +def IfcEllipse(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipse', 'IFC4X1', *args, **kwargs) + + +def IfcEllipseProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipseProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcEnergyConversionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDevice', 'IFC4X1', *args, **kwargs) + + +def IfcEnergyConversionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDeviceType', 'IFC4X1', *args, **kwargs) + + +def IfcEngine(*args, **kwargs): return ifcopenshell.create_entity('IfcEngine', 'IFC4X1', *args, **kwargs) + + +def IfcEngineType(*args, **kwargs): return ifcopenshell.create_entity('IfcEngineType', 'IFC4X1', *args, **kwargs) + + +def IfcEvaporativeCooler(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCooler', 'IFC4X1', *args, **kwargs) + + +def IfcEvaporativeCoolerType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCoolerType', 'IFC4X1', *args, **kwargs) + + +def IfcEvaporator(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporator', 'IFC4X1', *args, **kwargs) + + +def IfcEvaporatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporatorType', 'IFC4X1', *args, **kwargs) + + +def IfcEvent(*args, **kwargs): return ifcopenshell.create_entity('IfcEvent', 'IFC4X1', *args, **kwargs) + + +def IfcEventTime(*args, **kwargs): return ifcopenshell.create_entity('IfcEventTime', 'IFC4X1', *args, **kwargs) + + +def IfcEventType(*args, **kwargs): return ifcopenshell.create_entity('IfcEventType', 'IFC4X1', *args, **kwargs) + + +def IfcExtendedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcExtendedProperties', 'IFC4X1', *args, **kwargs) + + +def IfcExternalInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalInformation', 'IFC4X1', *args, **kwargs) + + +def IfcExternalReference(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReference', 'IFC4X1', *args, **kwargs) + + +def IfcExternalReferenceRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReferenceRelationship', 'IFC4X1', *args, **kwargs) + + +def IfcExternalSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialElement', 'IFC4X1', *args, **kwargs) + + +def IfcExternalSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialStructureElement', 'IFC4X1', *args, **kwargs) + + +def IfcExternallyDefinedHatchStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedHatchStyle', 'IFC4X1', *args, **kwargs) + + +def IfcExternallyDefinedSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedSurfaceStyle', 'IFC4X1', *args, **kwargs) + + +def IfcExternallyDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedTextFont', 'IFC4X1', *args, **kwargs) + + +def IfcExtrudedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolid', 'IFC4X1', *args, **kwargs) + + +def IfcExtrudedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolidTapered', 'IFC4X1', *args, **kwargs) + + +def IfcFace(*args, **kwargs): return ifcopenshell.create_entity('IfcFace', 'IFC4X1', *args, **kwargs) + + +def IfcFaceBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBasedSurfaceModel', 'IFC4X1', *args, **kwargs) + + +def IfcFaceBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBound', 'IFC4X1', *args, **kwargs) + + +def IfcFaceOuterBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceOuterBound', 'IFC4X1', *args, **kwargs) + + +def IfcFaceSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceSurface', 'IFC4X1', *args, **kwargs) + + +def IfcFacetedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrep', 'IFC4X1', *args, **kwargs) + + +def IfcFacetedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrepWithVoids', 'IFC4X1', *args, **kwargs) + + +def IfcFailureConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcFailureConnectionCondition', 'IFC4X1', *args, **kwargs) + + +def IfcFan(*args, **kwargs): return ifcopenshell.create_entity('IfcFan', 'IFC4X1', *args, **kwargs) + + +def IfcFanType(*args, **kwargs): return ifcopenshell.create_entity('IfcFanType', 'IFC4X1', *args, **kwargs) + + +def IfcFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcFastener', 'IFC4X1', *args, **kwargs) + + +def IfcFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFastenerType', 'IFC4X1', *args, **kwargs) + + +def IfcFeatureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElement', 'IFC4X1', *args, **kwargs) + + +def IfcFeatureElementAddition(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementAddition', 'IFC4X1', *args, **kwargs) + + +def IfcFeatureElementSubtraction(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementSubtraction', 'IFC4X1', *args, **kwargs) + + +def IfcFillAreaStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyle', 'IFC4X1', *args, **kwargs) + + +def IfcFillAreaStyleHatching(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleHatching', 'IFC4X1', *args, **kwargs) + + +def IfcFillAreaStyleTiles(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleTiles', 'IFC4X1', *args, **kwargs) + + +def IfcFilter(*args, **kwargs): return ifcopenshell.create_entity('IfcFilter', 'IFC4X1', *args, **kwargs) + + +def IfcFilterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFilterType', 'IFC4X1', *args, **kwargs) + + +def IfcFireSuppressionTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminal', 'IFC4X1', *args, **kwargs) + + +def IfcFireSuppressionTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminalType', 'IFC4X1', *args, **kwargs) + + +def IfcFixedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcFixedReferenceSweptAreaSolid', 'IFC4X1', *args, **kwargs) + + +def IfcFlowController(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowController', 'IFC4X1', *args, **kwargs) + + +def IfcFlowControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowControllerType', 'IFC4X1', *args, **kwargs) + + +def IfcFlowFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFitting', 'IFC4X1', *args, **kwargs) + + +def IfcFlowFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFittingType', 'IFC4X1', *args, **kwargs) + + +def IfcFlowInstrument(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrument', 'IFC4X1', *args, **kwargs) + + +def IfcFlowInstrumentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrumentType', 'IFC4X1', *args, **kwargs) + + +def IfcFlowMeter(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeter', 'IFC4X1', *args, **kwargs) + + +def IfcFlowMeterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeterType', 'IFC4X1', *args, **kwargs) + + +def IfcFlowMovingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDevice', 'IFC4X1', *args, **kwargs) + + +def IfcFlowMovingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDeviceType', 'IFC4X1', *args, **kwargs) + + +def IfcFlowSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegment', 'IFC4X1', *args, **kwargs) + + +def IfcFlowSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegmentType', 'IFC4X1', *args, **kwargs) + + +def IfcFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDevice', 'IFC4X1', *args, **kwargs) + + +def IfcFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDeviceType', 'IFC4X1', *args, **kwargs) + + +def IfcFlowTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminal', 'IFC4X1', *args, **kwargs) + + +def IfcFlowTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminalType', 'IFC4X1', *args, **kwargs) + + +def IfcFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDevice', 'IFC4X1', *args, **kwargs) + + +def IfcFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDeviceType', 'IFC4X1', *args, **kwargs) + + +def IfcFooting(*args, **kwargs): return ifcopenshell.create_entity('IfcFooting', 'IFC4X1', *args, **kwargs) + + +def IfcFootingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFootingType', 'IFC4X1', *args, **kwargs) + + +def IfcFurnishingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElement', 'IFC4X1', *args, **kwargs) + + +def IfcFurnishingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElementType', 'IFC4X1', *args, **kwargs) + + +def IfcFurniture(*args, **kwargs): return ifcopenshell.create_entity('IfcFurniture', 'IFC4X1', *args, **kwargs) + + +def IfcFurnitureType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnitureType', 'IFC4X1', *args, **kwargs) + + +def IfcGeographicElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElement', 'IFC4X1', *args, **kwargs) + + +def IfcGeographicElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElementType', 'IFC4X1', *args, **kwargs) + + +def IfcGeometricCurveSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricCurveSet', 'IFC4X1', *args, **kwargs) + + +def IfcGeometricRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationContext', 'IFC4X1', *args, **kwargs) + + +def IfcGeometricRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationItem', 'IFC4X1', *args, **kwargs) + + +def IfcGeometricRepresentationSubContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationSubContext', 'IFC4X1', *args, **kwargs) + + +def IfcGeometricSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricSet', 'IFC4X1', *args, **kwargs) + + +def IfcGrid(*args, **kwargs): return ifcopenshell.create_entity('IfcGrid', 'IFC4X1', *args, **kwargs) + + +def IfcGridAxis(*args, **kwargs): return ifcopenshell.create_entity('IfcGridAxis', 'IFC4X1', *args, **kwargs) + + +def IfcGridPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcGridPlacement', 'IFC4X1', *args, **kwargs) + + +def IfcGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcGroup', 'IFC4X1', *args, **kwargs) + + +def IfcHalfSpaceSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcHalfSpaceSolid', 'IFC4X1', *args, **kwargs) + + +def IfcHeatExchanger(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchanger', 'IFC4X1', *args, **kwargs) + + +def IfcHeatExchangerType(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchangerType', 'IFC4X1', *args, **kwargs) + + +def IfcHumidifier(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifier', 'IFC4X1', *args, **kwargs) + + +def IfcHumidifierType(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifierType', 'IFC4X1', *args, **kwargs) + + +def IfcIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcIShapeProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcImageTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcImageTexture', 'IFC4X1', *args, **kwargs) + + +def IfcIndexedColourMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedColourMap', 'IFC4X1', *args, **kwargs) + + +def IfcIndexedPolyCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolyCurve', 'IFC4X1', *args, **kwargs) + + +def IfcIndexedPolygonalFace(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFace', 'IFC4X1', *args, **kwargs) + + +def IfcIndexedPolygonalFaceWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFaceWithVoids', 'IFC4X1', *args, **kwargs) + + +def IfcIndexedTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTextureMap', 'IFC4X1', *args, **kwargs) + + +def IfcIndexedTriangleTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTriangleTextureMap', 'IFC4X1', *args, **kwargs) + + +def IfcInterceptor(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptor', 'IFC4X1', *args, **kwargs) + + +def IfcInterceptorType(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptorType', 'IFC4X1', *args, **kwargs) + + +def IfcIntersectionCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIntersectionCurve', 'IFC4X1', *args, **kwargs) + + +def IfcInventory(*args, **kwargs): return ifcopenshell.create_entity('IfcInventory', 'IFC4X1', *args, **kwargs) + + +def IfcIrregularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeries', 'IFC4X1', *args, **kwargs) + + +def IfcIrregularTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeriesValue', 'IFC4X1', *args, **kwargs) + + +def IfcJunctionBox(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBox', 'IFC4X1', *args, **kwargs) + + +def IfcJunctionBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBoxType', 'IFC4X1', *args, **kwargs) + + +def IfcLShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcLShapeProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcLaborResource(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResource', 'IFC4X1', *args, **kwargs) + + +def IfcLaborResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResourceType', 'IFC4X1', *args, **kwargs) + + +def IfcLagTime(*args, **kwargs): return ifcopenshell.create_entity('IfcLagTime', 'IFC4X1', *args, **kwargs) + + +def IfcLamp(*args, **kwargs): return ifcopenshell.create_entity('IfcLamp', 'IFC4X1', *args, **kwargs) + + +def IfcLampType(*args, **kwargs): return ifcopenshell.create_entity('IfcLampType', 'IFC4X1', *args, **kwargs) + + +def IfcLibraryInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryInformation', 'IFC4X1', *args, **kwargs) + + +def IfcLibraryReference(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryReference', 'IFC4X1', *args, **kwargs) + + +def IfcLightDistributionData(*args, **kwargs): return ifcopenshell.create_entity('IfcLightDistributionData', 'IFC4X1', *args, **kwargs) + + +def IfcLightFixture(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixture', 'IFC4X1', *args, **kwargs) + + +def IfcLightFixtureType(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixtureType', 'IFC4X1', *args, **kwargs) + + +def IfcLightIntensityDistribution(*args, **kwargs): return ifcopenshell.create_entity('IfcLightIntensityDistribution', 'IFC4X1', *args, **kwargs) + + +def IfcLightSource(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSource', 'IFC4X1', *args, **kwargs) + + +def IfcLightSourceAmbient(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceAmbient', 'IFC4X1', *args, **kwargs) + + +def IfcLightSourceDirectional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceDirectional', 'IFC4X1', *args, **kwargs) + + +def IfcLightSourceGoniometric(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceGoniometric', 'IFC4X1', *args, **kwargs) + + +def IfcLightSourcePositional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourcePositional', 'IFC4X1', *args, **kwargs) + + +def IfcLightSourceSpot(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceSpot', 'IFC4X1', *args, **kwargs) + + +def IfcLine(*args, **kwargs): return ifcopenshell.create_entity('IfcLine', 'IFC4X1', *args, **kwargs) + + +def IfcLineSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcLineSegment2D', 'IFC4X1', *args, **kwargs) + + +def IfcLinearPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPlacement', 'IFC4X1', *args, **kwargs) + + +def IfcLinearPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPositioningElement', 'IFC4X1', *args, **kwargs) + + +def IfcLocalPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLocalPlacement', 'IFC4X1', *args, **kwargs) + + +def IfcLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcLoop', 'IFC4X1', *args, **kwargs) + + +def IfcManifoldSolidBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcManifoldSolidBrep', 'IFC4X1', *args, **kwargs) + + +def IfcMapConversion(*args, **kwargs): return ifcopenshell.create_entity('IfcMapConversion', 'IFC4X1', *args, **kwargs) + + +def IfcMappedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcMappedItem', 'IFC4X1', *args, **kwargs) + + +def IfcMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterial', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialClassificationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialClassificationRelationship', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialConstituent(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituent', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialConstituentSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituentSet', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinition', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialDefinitionRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinitionRepresentation', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialLayer(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayer', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialLayerSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSet', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialLayerSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSetUsage', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialLayerWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerWithOffsets', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialList(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialList', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialProfile(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfile', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialProfileSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSet', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialProfileSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsage', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialProfileSetUsageTapering(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsageTapering', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialProfileWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileWithOffsets', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProperties', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialRelationship', 'IFC4X1', *args, **kwargs) + + +def IfcMaterialUsageDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialUsageDefinition', 'IFC4X1', *args, **kwargs) + + +def IfcMeasureWithUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMeasureWithUnit', 'IFC4X1', *args, **kwargs) + + +def IfcMechanicalFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastener', 'IFC4X1', *args, **kwargs) + + +def IfcMechanicalFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastenerType', 'IFC4X1', *args, **kwargs) + + +def IfcMedicalDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDevice', 'IFC4X1', *args, **kwargs) + + +def IfcMedicalDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDeviceType', 'IFC4X1', *args, **kwargs) + + +def IfcMember(*args, **kwargs): return ifcopenshell.create_entity('IfcMember', 'IFC4X1', *args, **kwargs) + + +def IfcMemberStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberStandardCase', 'IFC4X1', *args, **kwargs) + + +def IfcMemberType(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberType', 'IFC4X1', *args, **kwargs) + + +def IfcMetric(*args, **kwargs): return ifcopenshell.create_entity('IfcMetric', 'IFC4X1', *args, **kwargs) + + +def IfcMirroredProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcMirroredProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcMonetaryUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMonetaryUnit', 'IFC4X1', *args, **kwargs) + + +def IfcMotorConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnection', 'IFC4X1', *args, **kwargs) + + +def IfcMotorConnectionType(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnectionType', 'IFC4X1', *args, **kwargs) + + +def IfcNamedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcNamedUnit', 'IFC4X1', *args, **kwargs) + + +def IfcObject(*args, **kwargs): return ifcopenshell.create_entity('IfcObject', 'IFC4X1', *args, **kwargs) + + +def IfcObjectDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectDefinition', 'IFC4X1', *args, **kwargs) + + +def IfcObjectPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectPlacement', 'IFC4X1', *args, **kwargs) + + +def IfcObjective(*args, **kwargs): return ifcopenshell.create_entity('IfcObjective', 'IFC4X1', *args, **kwargs) + + +def IfcOccupant(*args, **kwargs): return ifcopenshell.create_entity('IfcOccupant', 'IFC4X1', *args, **kwargs) + + +def IfcOffsetCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve', 'IFC4X1', *args, **kwargs) + + +def IfcOffsetCurve2D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve2D', 'IFC4X1', *args, **kwargs) + + +def IfcOffsetCurve3D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve3D', 'IFC4X1', *args, **kwargs) + + +def IfcOffsetCurveByDistances(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurveByDistances', 'IFC4X1', *args, **kwargs) + + +def IfcOpenShell(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenShell', 'IFC4X1', *args, **kwargs) + + +def IfcOpeningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningElement', 'IFC4X1', *args, **kwargs) + + +def IfcOpeningStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningStandardCase', 'IFC4X1', *args, **kwargs) + + +def IfcOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganization', 'IFC4X1', *args, **kwargs) + + +def IfcOrganizationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganizationRelationship', 'IFC4X1', *args, **kwargs) + + +def IfcOrientationExpression(*args, **kwargs): return ifcopenshell.create_entity('IfcOrientationExpression', 'IFC4X1', *args, **kwargs) + + +def IfcOrientedEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcOrientedEdge', 'IFC4X1', *args, **kwargs) + + +def IfcOuterBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOuterBoundaryCurve', 'IFC4X1', *args, **kwargs) + + +def IfcOutlet(*args, **kwargs): return ifcopenshell.create_entity('IfcOutlet', 'IFC4X1', *args, **kwargs) + + +def IfcOutletType(*args, **kwargs): return ifcopenshell.create_entity('IfcOutletType', 'IFC4X1', *args, **kwargs) + + +def IfcOwnerHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcOwnerHistory', 'IFC4X1', *args, **kwargs) + + +def IfcParameterizedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcParameterizedProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcPath(*args, **kwargs): return ifcopenshell.create_entity('IfcPath', 'IFC4X1', *args, **kwargs) + + +def IfcPcurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPcurve', 'IFC4X1', *args, **kwargs) + + +def IfcPerformanceHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcPerformanceHistory', 'IFC4X1', *args, **kwargs) + + +def IfcPermeableCoveringProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPermeableCoveringProperties', 'IFC4X1', *args, **kwargs) + + +def IfcPermit(*args, **kwargs): return ifcopenshell.create_entity('IfcPermit', 'IFC4X1', *args, **kwargs) + + +def IfcPerson(*args, **kwargs): return ifcopenshell.create_entity('IfcPerson', 'IFC4X1', *args, **kwargs) + + +def IfcPersonAndOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcPersonAndOrganization', 'IFC4X1', *args, **kwargs) + + +def IfcPhysicalComplexQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalComplexQuantity', 'IFC4X1', *args, **kwargs) + + +def IfcPhysicalQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalQuantity', 'IFC4X1', *args, **kwargs) + + +def IfcPhysicalSimpleQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalSimpleQuantity', 'IFC4X1', *args, **kwargs) + + +def IfcPile(*args, **kwargs): return ifcopenshell.create_entity('IfcPile', 'IFC4X1', *args, **kwargs) + + +def IfcPileType(*args, **kwargs): return ifcopenshell.create_entity('IfcPileType', 'IFC4X1', *args, **kwargs) + + +def IfcPipeFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFitting', 'IFC4X1', *args, **kwargs) + + +def IfcPipeFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFittingType', 'IFC4X1', *args, **kwargs) + + +def IfcPipeSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegment', 'IFC4X1', *args, **kwargs) + + +def IfcPipeSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegmentType', 'IFC4X1', *args, **kwargs) + + +def IfcPixelTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcPixelTexture', 'IFC4X1', *args, **kwargs) + + +def IfcPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcPlacement', 'IFC4X1', *args, **kwargs) + + +def IfcPlanarBox(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarBox', 'IFC4X1', *args, **kwargs) + + +def IfcPlanarExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarExtent', 'IFC4X1', *args, **kwargs) + + +def IfcPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcPlane', 'IFC4X1', *args, **kwargs) + + +def IfcPlate(*args, **kwargs): return ifcopenshell.create_entity('IfcPlate', 'IFC4X1', *args, **kwargs) + + +def IfcPlateStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateStandardCase', 'IFC4X1', *args, **kwargs) + + +def IfcPlateType(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateType', 'IFC4X1', *args, **kwargs) + + +def IfcPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcPoint', 'IFC4X1', *args, **kwargs) + + +def IfcPointOnCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnCurve', 'IFC4X1', *args, **kwargs) + + +def IfcPointOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnSurface', 'IFC4X1', *args, **kwargs) + + +def IfcPolyLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyLoop', 'IFC4X1', *args, **kwargs) + + +def IfcPolygonalBoundedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalBoundedHalfSpace', 'IFC4X1', *args, **kwargs) + + +def IfcPolygonalFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalFaceSet', 'IFC4X1', *args, **kwargs) + + +def IfcPolyline(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyline', 'IFC4X1', *args, **kwargs) + + +def IfcPort(*args, **kwargs): return ifcopenshell.create_entity('IfcPort', 'IFC4X1', *args, **kwargs) + + +def IfcPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcPositioningElement', 'IFC4X1', *args, **kwargs) + + +def IfcPostalAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcPostalAddress', 'IFC4X1', *args, **kwargs) + + +def IfcPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedColour', 'IFC4X1', *args, **kwargs) + + +def IfcPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedCurveFont', 'IFC4X1', *args, **kwargs) + + +def IfcPreDefinedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedItem', 'IFC4X1', *args, **kwargs) + + +def IfcPreDefinedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedProperties', 'IFC4X1', *args, **kwargs) + + +def IfcPreDefinedPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedPropertySet', 'IFC4X1', *args, **kwargs) + + +def IfcPreDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedTextFont', 'IFC4X1', *args, **kwargs) + + +def IfcPresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationItem', 'IFC4X1', *args, **kwargs) + + +def IfcPresentationLayerAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerAssignment', 'IFC4X1', *args, **kwargs) + + +def IfcPresentationLayerWithStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerWithStyle', 'IFC4X1', *args, **kwargs) + + +def IfcPresentationStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyle', 'IFC4X1', *args, **kwargs) + + +def IfcPresentationStyleAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyleAssignment', 'IFC4X1', *args, **kwargs) + + +def IfcProcedure(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedure', 'IFC4X1', *args, **kwargs) + + +def IfcProcedureType(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedureType', 'IFC4X1', *args, **kwargs) + + +def IfcProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcProcess', 'IFC4X1', *args, **kwargs) + + +def IfcProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcProduct', 'IFC4X1', *args, **kwargs) + + +def IfcProductDefinitionShape(*args, **kwargs): return ifcopenshell.create_entity('IfcProductDefinitionShape', 'IFC4X1', *args, **kwargs) + + +def IfcProductRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcProductRepresentation', 'IFC4X1', *args, **kwargs) + + +def IfcProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileProperties', 'IFC4X1', *args, **kwargs) + + +def IfcProject(*args, **kwargs): return ifcopenshell.create_entity('IfcProject', 'IFC4X1', *args, **kwargs) + + +def IfcProjectLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectLibrary', 'IFC4X1', *args, **kwargs) + + +def IfcProjectOrder(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectOrder', 'IFC4X1', *args, **kwargs) + + +def IfcProjectedCRS(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectedCRS', 'IFC4X1', *args, **kwargs) + + +def IfcProjectionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectionElement', 'IFC4X1', *args, **kwargs) + + +def IfcProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcProperty', 'IFC4X1', *args, **kwargs) + + +def IfcPropertyAbstraction(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyAbstraction', 'IFC4X1', *args, **kwargs) + + +def IfcPropertyBoundedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyBoundedValue', 'IFC4X1', *args, **kwargs) + + +def IfcPropertyDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDefinition', 'IFC4X1', *args, **kwargs) + + +def IfcPropertyDependencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDependencyRelationship', 'IFC4X1', *args, **kwargs) + + +def IfcPropertyEnumeratedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeratedValue', 'IFC4X1', *args, **kwargs) + + +def IfcPropertyEnumeration(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeration', 'IFC4X1', *args, **kwargs) + + +def IfcPropertyListValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyListValue', 'IFC4X1', *args, **kwargs) + + +def IfcPropertyReferenceValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyReferenceValue', 'IFC4X1', *args, **kwargs) + + +def IfcPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySet', 'IFC4X1', *args, **kwargs) + + +def IfcPropertySetDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetDefinition', 'IFC4X1', *args, **kwargs) + + +def IfcPropertySetTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetTemplate', 'IFC4X1', *args, **kwargs) + + +def IfcPropertySingleValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySingleValue', 'IFC4X1', *args, **kwargs) + + +def IfcPropertyTableValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTableValue', 'IFC4X1', *args, **kwargs) + + +def IfcPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplate', 'IFC4X1', *args, **kwargs) + + +def IfcPropertyTemplateDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplateDefinition', 'IFC4X1', *args, **kwargs) + + +def IfcProtectiveDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDevice', 'IFC4X1', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnit', 'IFC4X1', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnitType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnitType', 'IFC4X1', *args, **kwargs) + + +def IfcProtectiveDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceType', 'IFC4X1', *args, **kwargs) + + +def IfcProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcProxy', 'IFC4X1', *args, **kwargs) + + +def IfcPump(*args, **kwargs): return ifcopenshell.create_entity('IfcPump', 'IFC4X1', *args, **kwargs) + + +def IfcPumpType(*args, **kwargs): return ifcopenshell.create_entity('IfcPumpType', 'IFC4X1', *args, **kwargs) + + +def IfcQuantityArea(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityArea', 'IFC4X1', *args, **kwargs) + + +def IfcQuantityCount(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityCount', 'IFC4X1', *args, **kwargs) + + +def IfcQuantityLength(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityLength', 'IFC4X1', *args, **kwargs) + + +def IfcQuantitySet(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantitySet', 'IFC4X1', *args, **kwargs) + + +def IfcQuantityTime(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityTime', 'IFC4X1', *args, **kwargs) + + +def IfcQuantityVolume(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityVolume', 'IFC4X1', *args, **kwargs) + + +def IfcQuantityWeight(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityWeight', 'IFC4X1', *args, **kwargs) + + +def IfcRailing(*args, **kwargs): return ifcopenshell.create_entity('IfcRailing', 'IFC4X1', *args, **kwargs) + + +def IfcRailingType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailingType', 'IFC4X1', *args, **kwargs) + + +def IfcRamp(*args, **kwargs): return ifcopenshell.create_entity('IfcRamp', 'IFC4X1', *args, **kwargs) + + +def IfcRampFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlight', 'IFC4X1', *args, **kwargs) + + +def IfcRampFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlightType', 'IFC4X1', *args, **kwargs) + + +def IfcRampType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampType', 'IFC4X1', *args, **kwargs) + + +def IfcRationalBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineCurveWithKnots', 'IFC4X1', *args, **kwargs) + + +def IfcRationalBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineSurfaceWithKnots', 'IFC4X1', *args, **kwargs) + + +def IfcRectangleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleHollowProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcRectangularPyramid(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularPyramid', 'IFC4X1', *args, **kwargs) + + +def IfcRectangularTrimmedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularTrimmedSurface', 'IFC4X1', *args, **kwargs) + + +def IfcRecurrencePattern(*args, **kwargs): return ifcopenshell.create_entity('IfcRecurrencePattern', 'IFC4X1', *args, **kwargs) + + +def IfcReference(*args, **kwargs): return ifcopenshell.create_entity('IfcReference', 'IFC4X1', *args, **kwargs) + + +def IfcReferent(*args, **kwargs): return ifcopenshell.create_entity('IfcReferent', 'IFC4X1', *args, **kwargs) + + +def IfcRegularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcRegularTimeSeries', 'IFC4X1', *args, **kwargs) + + +def IfcReinforcementBarProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementBarProperties', 'IFC4X1', *args, **kwargs) + + +def IfcReinforcementDefinitionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementDefinitionProperties', 'IFC4X1', *args, **kwargs) + + +def IfcReinforcingBar(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBar', 'IFC4X1', *args, **kwargs) + + +def IfcReinforcingBarType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBarType', 'IFC4X1', *args, **kwargs) + + +def IfcReinforcingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElement', 'IFC4X1', *args, **kwargs) + + +def IfcReinforcingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElementType', 'IFC4X1', *args, **kwargs) + + +def IfcReinforcingMesh(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMesh', 'IFC4X1', *args, **kwargs) + + +def IfcReinforcingMeshType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMeshType', 'IFC4X1', *args, **kwargs) + + +def IfcRelAggregates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAggregates', 'IFC4X1', *args, **kwargs) + + +def IfcRelAssigns(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssigns', 'IFC4X1', *args, **kwargs) + + +def IfcRelAssignsToActor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToActor', 'IFC4X1', *args, **kwargs) + + +def IfcRelAssignsToControl(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToControl', 'IFC4X1', *args, **kwargs) + + +def IfcRelAssignsToGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroup', 'IFC4X1', *args, **kwargs) + + +def IfcRelAssignsToGroupByFactor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroupByFactor', 'IFC4X1', *args, **kwargs) + + +def IfcRelAssignsToProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProcess', 'IFC4X1', *args, **kwargs) + + +def IfcRelAssignsToProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProduct', 'IFC4X1', *args, **kwargs) + + +def IfcRelAssignsToResource(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToResource', 'IFC4X1', *args, **kwargs) + + +def IfcRelAssociates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociates', 'IFC4X1', *args, **kwargs) + + +def IfcRelAssociatesApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesApproval', 'IFC4X1', *args, **kwargs) + + +def IfcRelAssociatesClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesClassification', 'IFC4X1', *args, **kwargs) + + +def IfcRelAssociatesConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesConstraint', 'IFC4X1', *args, **kwargs) + + +def IfcRelAssociatesDocument(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesDocument', 'IFC4X1', *args, **kwargs) + + +def IfcRelAssociatesLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesLibrary', 'IFC4X1', *args, **kwargs) + + +def IfcRelAssociatesMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesMaterial', 'IFC4X1', *args, **kwargs) + + +def IfcRelConnects(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnects', 'IFC4X1', *args, **kwargs) + + +def IfcRelConnectsElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsElements', 'IFC4X1', *args, **kwargs) + + +def IfcRelConnectsPathElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPathElements', 'IFC4X1', *args, **kwargs) + + +def IfcRelConnectsPortToElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPortToElement', 'IFC4X1', *args, **kwargs) + + +def IfcRelConnectsPorts(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPorts', 'IFC4X1', *args, **kwargs) + + +def IfcRelConnectsStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralActivity', 'IFC4X1', *args, **kwargs) + + +def IfcRelConnectsStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralMember', 'IFC4X1', *args, **kwargs) + + +def IfcRelConnectsWithEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithEccentricity', 'IFC4X1', *args, **kwargs) + + +def IfcRelConnectsWithRealizingElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithRealizingElements', 'IFC4X1', *args, **kwargs) + + +def IfcRelContainedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelContainedInSpatialStructure', 'IFC4X1', *args, **kwargs) + + +def IfcRelCoversBldgElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversBldgElements', 'IFC4X1', *args, **kwargs) + + +def IfcRelCoversSpaces(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversSpaces', 'IFC4X1', *args, **kwargs) + + +def IfcRelDeclares(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDeclares', 'IFC4X1', *args, **kwargs) + + +def IfcRelDecomposes(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDecomposes', 'IFC4X1', *args, **kwargs) + + +def IfcRelDefines(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefines', 'IFC4X1', *args, **kwargs) + + +def IfcRelDefinesByObject(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByObject', 'IFC4X1', *args, **kwargs) + + +def IfcRelDefinesByProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByProperties', 'IFC4X1', *args, **kwargs) + + +def IfcRelDefinesByTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByTemplate', 'IFC4X1', *args, **kwargs) + + +def IfcRelDefinesByType(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByType', 'IFC4X1', *args, **kwargs) + + +def IfcRelFillsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFillsElement', 'IFC4X1', *args, **kwargs) + + +def IfcRelFlowControlElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFlowControlElements', 'IFC4X1', *args, **kwargs) + + +def IfcRelInterferesElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelInterferesElements', 'IFC4X1', *args, **kwargs) + + +def IfcRelNests(*args, **kwargs): return ifcopenshell.create_entity('IfcRelNests', 'IFC4X1', *args, **kwargs) + + +def IfcRelProjectsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelProjectsElement', 'IFC4X1', *args, **kwargs) + + +def IfcRelReferencedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelReferencedInSpatialStructure', 'IFC4X1', *args, **kwargs) + + +def IfcRelSequence(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSequence', 'IFC4X1', *args, **kwargs) + + +def IfcRelServicesBuildings(*args, **kwargs): return ifcopenshell.create_entity('IfcRelServicesBuildings', 'IFC4X1', *args, **kwargs) + + +def IfcRelSpaceBoundary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary', 'IFC4X1', *args, **kwargs) + + +def IfcRelSpaceBoundary1stLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary1stLevel', 'IFC4X1', *args, **kwargs) + + +def IfcRelSpaceBoundary2ndLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary2ndLevel', 'IFC4X1', *args, **kwargs) + + +def IfcRelVoidsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelVoidsElement', 'IFC4X1', *args, **kwargs) + + +def IfcRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcRelationship', 'IFC4X1', *args, **kwargs) + + +def IfcReparametrisedCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcReparametrisedCompositeCurveSegment', 'IFC4X1', *args, **kwargs) + + +def IfcRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentation', 'IFC4X1', *args, **kwargs) + + +def IfcRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationContext', 'IFC4X1', *args, **kwargs) + + +def IfcRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationItem', 'IFC4X1', *args, **kwargs) + + +def IfcRepresentationMap(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationMap', 'IFC4X1', *args, **kwargs) + + +def IfcResource(*args, **kwargs): return ifcopenshell.create_entity('IfcResource', 'IFC4X1', *args, **kwargs) + + +def IfcResourceApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceApprovalRelationship', 'IFC4X1', *args, **kwargs) + + +def IfcResourceConstraintRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceConstraintRelationship', 'IFC4X1', *args, **kwargs) + + +def IfcResourceLevelRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceLevelRelationship', 'IFC4X1', *args, **kwargs) + + +def IfcResourceTime(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceTime', 'IFC4X1', *args, **kwargs) + + +def IfcRevolvedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolid', 'IFC4X1', *args, **kwargs) + + +def IfcRevolvedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolidTapered', 'IFC4X1', *args, **kwargs) + + +def IfcRightCircularCone(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCone', 'IFC4X1', *args, **kwargs) + + +def IfcRightCircularCylinder(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCylinder', 'IFC4X1', *args, **kwargs) + + +def IfcRoof(*args, **kwargs): return ifcopenshell.create_entity('IfcRoof', 'IFC4X1', *args, **kwargs) + + +def IfcRoofType(*args, **kwargs): return ifcopenshell.create_entity('IfcRoofType', 'IFC4X1', *args, **kwargs) + + +def IfcRoot(*args, **kwargs): return ifcopenshell.create_entity('IfcRoot', 'IFC4X1', *args, **kwargs) + + +def IfcRoundedRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRoundedRectangleProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcSIUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcSIUnit', 'IFC4X1', *args, **kwargs) + + +def IfcSanitaryTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminal', 'IFC4X1', *args, **kwargs) + + +def IfcSanitaryTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminalType', 'IFC4X1', *args, **kwargs) + + +def IfcSchedulingTime(*args, **kwargs): return ifcopenshell.create_entity('IfcSchedulingTime', 'IFC4X1', *args, **kwargs) + + +def IfcSeamCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSeamCurve', 'IFC4X1', *args, **kwargs) + + +def IfcSectionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionProperties', 'IFC4X1', *args, **kwargs) + + +def IfcSectionReinforcementProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionReinforcementProperties', 'IFC4X1', *args, **kwargs) + + +def IfcSectionedSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolid', 'IFC4X1', *args, **kwargs) + + +def IfcSectionedSolidHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolidHorizontal', 'IFC4X1', *args, **kwargs) + + +def IfcSectionedSpine(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSpine', 'IFC4X1', *args, **kwargs) + + +def IfcSensor(*args, **kwargs): return ifcopenshell.create_entity('IfcSensor', 'IFC4X1', *args, **kwargs) + + +def IfcSensorType(*args, **kwargs): return ifcopenshell.create_entity('IfcSensorType', 'IFC4X1', *args, **kwargs) + + +def IfcShadingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDevice', 'IFC4X1', *args, **kwargs) + + +def IfcShadingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDeviceType', 'IFC4X1', *args, **kwargs) + + +def IfcShapeAspect(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeAspect', 'IFC4X1', *args, **kwargs) + + +def IfcShapeModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeModel', 'IFC4X1', *args, **kwargs) + + +def IfcShapeRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeRepresentation', 'IFC4X1', *args, **kwargs) + + +def IfcShellBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShellBasedSurfaceModel', 'IFC4X1', *args, **kwargs) + + +def IfcSimpleProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcSimpleProperty', 'IFC4X1', *args, **kwargs) + + +def IfcSimplePropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcSimplePropertyTemplate', 'IFC4X1', *args, **kwargs) + + +def IfcSite(*args, **kwargs): return ifcopenshell.create_entity('IfcSite', 'IFC4X1', *args, **kwargs) + + +def IfcSlab(*args, **kwargs): return ifcopenshell.create_entity('IfcSlab', 'IFC4X1', *args, **kwargs) + + +def IfcSlabElementedCase(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabElementedCase', 'IFC4X1', *args, **kwargs) + + +def IfcSlabStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabStandardCase', 'IFC4X1', *args, **kwargs) + + +def IfcSlabType(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabType', 'IFC4X1', *args, **kwargs) + + +def IfcSlippageConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcSlippageConnectionCondition', 'IFC4X1', *args, **kwargs) + + +def IfcSolarDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDevice', 'IFC4X1', *args, **kwargs) + + +def IfcSolarDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDeviceType', 'IFC4X1', *args, **kwargs) + + +def IfcSolidModel(*args, **kwargs): return ifcopenshell.create_entity('IfcSolidModel', 'IFC4X1', *args, **kwargs) + + +def IfcSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcSpace', 'IFC4X1', *args, **kwargs) + + +def IfcSpaceHeater(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeater', 'IFC4X1', *args, **kwargs) + + +def IfcSpaceHeaterType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeaterType', 'IFC4X1', *args, **kwargs) + + +def IfcSpaceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceType', 'IFC4X1', *args, **kwargs) + + +def IfcSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElement', 'IFC4X1', *args, **kwargs) + + +def IfcSpatialElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElementType', 'IFC4X1', *args, **kwargs) + + +def IfcSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElement', 'IFC4X1', *args, **kwargs) + + +def IfcSpatialStructureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElementType', 'IFC4X1', *args, **kwargs) + + +def IfcSpatialZone(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZone', 'IFC4X1', *args, **kwargs) + + +def IfcSpatialZoneType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZoneType', 'IFC4X1', *args, **kwargs) + + +def IfcSphere(*args, **kwargs): return ifcopenshell.create_entity('IfcSphere', 'IFC4X1', *args, **kwargs) + + +def IfcSphericalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSphericalSurface', 'IFC4X1', *args, **kwargs) + + +def IfcStackTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminal', 'IFC4X1', *args, **kwargs) + + +def IfcStackTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminalType', 'IFC4X1', *args, **kwargs) + + +def IfcStair(*args, **kwargs): return ifcopenshell.create_entity('IfcStair', 'IFC4X1', *args, **kwargs) + + +def IfcStairFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlight', 'IFC4X1', *args, **kwargs) + + +def IfcStairFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlightType', 'IFC4X1', *args, **kwargs) + + +def IfcStairType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairType', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAction', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralActivity', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralAnalysisModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAnalysisModel', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnection', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnectionCondition', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralCurveAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveAction', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralCurveConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveConnection', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralCurveMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMember', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralCurveMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMemberVarying', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralCurveReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveReaction', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralItem', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralLinearAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLinearAction', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralLoad(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoad', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralLoadCase(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadCase', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralLoadConfiguration(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadConfiguration', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralLoadGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadGroup', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralLoadLinearForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadLinearForce', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralLoadOrResult(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadOrResult', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralLoadPlanarForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadPlanarForce', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacement(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacement', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacementDistortion(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacementDistortion', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralLoadSingleForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForce', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralLoadSingleForceWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForceWarping', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralLoadStatic(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadStatic', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralLoadTemperature(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadTemperature', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralMember', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralPlanarAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPlanarAction', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralPointAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointAction', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralPointConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointConnection', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralPointReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointReaction', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralReaction', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralResultGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralResultGroup', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralSurfaceAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceAction', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralSurfaceConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceConnection', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralSurfaceMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMember', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralSurfaceMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMemberVarying', 'IFC4X1', *args, **kwargs) + + +def IfcStructuralSurfaceReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceReaction', 'IFC4X1', *args, **kwargs) + + +def IfcStyleModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStyleModel', 'IFC4X1', *args, **kwargs) + + +def IfcStyledItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledItem', 'IFC4X1', *args, **kwargs) + + +def IfcStyledRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledRepresentation', 'IFC4X1', *args, **kwargs) + + +def IfcSubContractResource(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResource', 'IFC4X1', *args, **kwargs) + + +def IfcSubContractResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResourceType', 'IFC4X1', *args, **kwargs) + + +def IfcSubedge(*args, **kwargs): return ifcopenshell.create_entity('IfcSubedge', 'IFC4X1', *args, **kwargs) + + +def IfcSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSurface', 'IFC4X1', *args, **kwargs) + + +def IfcSurfaceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurve', 'IFC4X1', *args, **kwargs) + + +def IfcSurfaceCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurveSweptAreaSolid', 'IFC4X1', *args, **kwargs) + + +def IfcSurfaceFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceFeature', 'IFC4X1', *args, **kwargs) + + +def IfcSurfaceOfLinearExtrusion(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfLinearExtrusion', 'IFC4X1', *args, **kwargs) + + +def IfcSurfaceOfRevolution(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfRevolution', 'IFC4X1', *args, **kwargs) + + +def IfcSurfaceReinforcementArea(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceReinforcementArea', 'IFC4X1', *args, **kwargs) + + +def IfcSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyle', 'IFC4X1', *args, **kwargs) + + +def IfcSurfaceStyleLighting(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleLighting', 'IFC4X1', *args, **kwargs) + + +def IfcSurfaceStyleRefraction(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRefraction', 'IFC4X1', *args, **kwargs) + + +def IfcSurfaceStyleRendering(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRendering', 'IFC4X1', *args, **kwargs) + + +def IfcSurfaceStyleShading(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleShading', 'IFC4X1', *args, **kwargs) + + +def IfcSurfaceStyleWithTextures(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleWithTextures', 'IFC4X1', *args, **kwargs) + + +def IfcSurfaceTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceTexture', 'IFC4X1', *args, **kwargs) + + +def IfcSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptAreaSolid', 'IFC4X1', *args, **kwargs) + + +def IfcSweptDiskSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolid', 'IFC4X1', *args, **kwargs) + + +def IfcSweptDiskSolidPolygonal(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolidPolygonal', 'IFC4X1', *args, **kwargs) + + +def IfcSweptSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptSurface', 'IFC4X1', *args, **kwargs) + + +def IfcSwitchingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDevice', 'IFC4X1', *args, **kwargs) + + +def IfcSwitchingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDeviceType', 'IFC4X1', *args, **kwargs) + + +def IfcSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcSystem', 'IFC4X1', *args, **kwargs) + + +def IfcSystemFurnitureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElement', 'IFC4X1', *args, **kwargs) + + +def IfcSystemFurnitureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElementType', 'IFC4X1', *args, **kwargs) + + +def IfcTShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTShapeProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcTable(*args, **kwargs): return ifcopenshell.create_entity('IfcTable', 'IFC4X1', *args, **kwargs) + + +def IfcTableColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcTableColumn', 'IFC4X1', *args, **kwargs) + + +def IfcTableRow(*args, **kwargs): return ifcopenshell.create_entity('IfcTableRow', 'IFC4X1', *args, **kwargs) + + +def IfcTank(*args, **kwargs): return ifcopenshell.create_entity('IfcTank', 'IFC4X1', *args, **kwargs) + + +def IfcTankType(*args, **kwargs): return ifcopenshell.create_entity('IfcTankType', 'IFC4X1', *args, **kwargs) + + +def IfcTask(*args, **kwargs): return ifcopenshell.create_entity('IfcTask', 'IFC4X1', *args, **kwargs) + + +def IfcTaskTime(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTime', 'IFC4X1', *args, **kwargs) + + +def IfcTaskTimeRecurring(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTimeRecurring', 'IFC4X1', *args, **kwargs) + + +def IfcTaskType(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskType', 'IFC4X1', *args, **kwargs) + + +def IfcTelecomAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcTelecomAddress', 'IFC4X1', *args, **kwargs) + + +def IfcTendon(*args, **kwargs): return ifcopenshell.create_entity('IfcTendon', 'IFC4X1', *args, **kwargs) + + +def IfcTendonAnchor(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchor', 'IFC4X1', *args, **kwargs) + + +def IfcTendonAnchorType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchorType', 'IFC4X1', *args, **kwargs) + + +def IfcTendonType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonType', 'IFC4X1', *args, **kwargs) + + +def IfcTessellatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedFaceSet', 'IFC4X1', *args, **kwargs) + + +def IfcTessellatedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedItem', 'IFC4X1', *args, **kwargs) + + +def IfcTextLiteral(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteral', 'IFC4X1', *args, **kwargs) + + +def IfcTextLiteralWithExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteralWithExtent', 'IFC4X1', *args, **kwargs) + + +def IfcTextStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyle', 'IFC4X1', *args, **kwargs) + + +def IfcTextStyleFontModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleFontModel', 'IFC4X1', *args, **kwargs) + + +def IfcTextStyleForDefinedFont(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleForDefinedFont', 'IFC4X1', *args, **kwargs) + + +def IfcTextStyleTextModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleTextModel', 'IFC4X1', *args, **kwargs) + + +def IfcTextureCoordinate(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinate', 'IFC4X1', *args, **kwargs) + + +def IfcTextureCoordinateGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateGenerator', 'IFC4X1', *args, **kwargs) + + +def IfcTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureMap', 'IFC4X1', *args, **kwargs) + + +def IfcTextureVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertex', 'IFC4X1', *args, **kwargs) + + +def IfcTextureVertexList(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertexList', 'IFC4X1', *args, **kwargs) + + +def IfcTimePeriod(*args, **kwargs): return ifcopenshell.create_entity('IfcTimePeriod', 'IFC4X1', *args, **kwargs) + + +def IfcTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeries', 'IFC4X1', *args, **kwargs) + + +def IfcTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeriesValue', 'IFC4X1', *args, **kwargs) + + +def IfcTopologicalRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologicalRepresentationItem', 'IFC4X1', *args, **kwargs) + + +def IfcTopologyRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologyRepresentation', 'IFC4X1', *args, **kwargs) + + +def IfcToroidalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcToroidalSurface', 'IFC4X1', *args, **kwargs) + + +def IfcTransformer(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformer', 'IFC4X1', *args, **kwargs) + + +def IfcTransformerType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformerType', 'IFC4X1', *args, **kwargs) + + +def IfcTransitionCurveSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcTransitionCurveSegment2D', 'IFC4X1', *args, **kwargs) + + +def IfcTransportElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElement', 'IFC4X1', *args, **kwargs) + + +def IfcTransportElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElementType', 'IFC4X1', *args, **kwargs) + + +def IfcTrapeziumProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTrapeziumProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcTriangulatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedFaceSet', 'IFC4X1', *args, **kwargs) + + +def IfcTriangulatedIrregularNetwork(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedIrregularNetwork', 'IFC4X1', *args, **kwargs) + + +def IfcTrimmedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcTrimmedCurve', 'IFC4X1', *args, **kwargs) + + +def IfcTubeBundle(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundle', 'IFC4X1', *args, **kwargs) + + +def IfcTubeBundleType(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundleType', 'IFC4X1', *args, **kwargs) + + +def IfcTypeObject(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeObject', 'IFC4X1', *args, **kwargs) + + +def IfcTypeProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProcess', 'IFC4X1', *args, **kwargs) + + +def IfcTypeProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProduct', 'IFC4X1', *args, **kwargs) + + +def IfcTypeResource(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeResource', 'IFC4X1', *args, **kwargs) + + +def IfcUShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcUShapeProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcUnitAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitAssignment', 'IFC4X1', *args, **kwargs) + + +def IfcUnitaryControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElement', 'IFC4X1', *args, **kwargs) + + +def IfcUnitaryControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElementType', 'IFC4X1', *args, **kwargs) + + +def IfcUnitaryEquipment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipment', 'IFC4X1', *args, **kwargs) + + +def IfcUnitaryEquipmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipmentType', 'IFC4X1', *args, **kwargs) + + +def IfcValve(*args, **kwargs): return ifcopenshell.create_entity('IfcValve', 'IFC4X1', *args, **kwargs) + + +def IfcValveType(*args, **kwargs): return ifcopenshell.create_entity('IfcValveType', 'IFC4X1', *args, **kwargs) + + +def IfcVector(*args, **kwargs): return ifcopenshell.create_entity('IfcVector', 'IFC4X1', *args, **kwargs) + + +def IfcVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcVertex', 'IFC4X1', *args, **kwargs) + + +def IfcVertexLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexLoop', 'IFC4X1', *args, **kwargs) + + +def IfcVertexPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexPoint', 'IFC4X1', *args, **kwargs) + + +def IfcVibrationIsolator(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolator', 'IFC4X1', *args, **kwargs) + + +def IfcVibrationIsolatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolatorType', 'IFC4X1', *args, **kwargs) + + +def IfcVirtualElement(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualElement', 'IFC4X1', *args, **kwargs) + + +def IfcVirtualGridIntersection(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualGridIntersection', 'IFC4X1', *args, **kwargs) + + +def IfcVoidingFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcVoidingFeature', 'IFC4X1', *args, **kwargs) + + +def IfcWall(*args, **kwargs): return ifcopenshell.create_entity('IfcWall', 'IFC4X1', *args, **kwargs) + + +def IfcWallElementedCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallElementedCase', 'IFC4X1', *args, **kwargs) + + +def IfcWallStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallStandardCase', 'IFC4X1', *args, **kwargs) + + +def IfcWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcWallType', 'IFC4X1', *args, **kwargs) + + +def IfcWasteTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminal', 'IFC4X1', *args, **kwargs) + + +def IfcWasteTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminalType', 'IFC4X1', *args, **kwargs) + + +def IfcWindow(*args, **kwargs): return ifcopenshell.create_entity('IfcWindow', 'IFC4X1', *args, **kwargs) + + +def IfcWindowLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowLiningProperties', 'IFC4X1', *args, **kwargs) + + +def IfcWindowPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowPanelProperties', 'IFC4X1', *args, **kwargs) + + +def IfcWindowStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowStandardCase', 'IFC4X1', *args, **kwargs) + + +def IfcWindowStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowStyle', 'IFC4X1', *args, **kwargs) + + +def IfcWindowType(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowType', 'IFC4X1', *args, **kwargs) + + +def IfcWorkCalendar(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkCalendar', 'IFC4X1', *args, **kwargs) + + +def IfcWorkControl(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkControl', 'IFC4X1', *args, **kwargs) + + +def IfcWorkPlan(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkPlan', 'IFC4X1', *args, **kwargs) + + +def IfcWorkSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkSchedule', 'IFC4X1', *args, **kwargs) + + +def IfcWorkTime(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkTime', 'IFC4X1', *args, **kwargs) + + +def IfcZShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcZShapeProfileDef', 'IFC4X1', *args, **kwargs) + + +def IfcZone(*args, **kwargs): return ifcopenshell.create_entity('IfcZone', 'IFC4X1', *args, **kwargs) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcBoxAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcBoxAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['top-left','top-middle','top-right','middle-left','center','middle-right','bottom-left','bottom-middle','bottom-right'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCardinalPointReference_GreaterThanZero: + SCOPE = "type" + TYPE_NAME = "IfcCardinalPointReference" + RULE_NAME = "GreaterThanZero" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCompoundPlaneAngleMeasure_MinutesInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MinutesInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[2 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_SecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "SecondsInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[3 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_MicrosecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MicrosecondsInRange" + + @staticmethod + def __call__(self): + + + assert (sizeof(self) == 3) or ((abs(self[4 - 1])) < 1000000) + + + + +class IfcCompoundPlaneAngleMeasure_ConsistentSign: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "ConsistentSign" + + @staticmethod + def __call__(self): + + + assert (((self[1 - 1]) >= 0) and ((self[2 - 1]) >= 0) and ((self[3 - 1]) >= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) >= 0))) or (((self[1 - 1]) <= 0) and ((self[2 - 1]) <= 0) and ((self[3 - 1]) <= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) <= 0))) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDayInMonthNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInMonthNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 31 + + + + + +class IfcDayInWeekNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInWeekNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 7 + + + + + + + + + + + + + + + + + +class IfcDimensionCount_WR1: + SCOPE = "type" + TYPE_NAME = "IfcDimensionCount" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0 < self <= 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFontStyle_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontStyle" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','italic','oblique'] + + + + + +class IfcFontVariant_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontVariant" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps'] + + + + + +class IfcFontWeight_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontWeight" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps','100','200','300','400','500','600','700','800','900'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcHeatingValueMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcHeatingValueMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMonthInYearNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcMonthInYearNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 12 + + + + + + + + +class IfcNonNegativeLengthMeasure_NotNegative: + SCOPE = "type" + TYPE_NAME = "IfcNonNegativeLengthMeasure" + RULE_NAME = "NotNegative" + + @staticmethod + def __call__(self): + + + assert self >= 0. + + + + + +class IfcNormalisedRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcNormalisedRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPHMeasure_WR21: + SCOPE = "type" + TYPE_NAME = "IfcPHMeasure" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 14.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPositiveInteger_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveInteger" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + +class IfcPositiveLengthMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveLengthMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositivePlaneAngleMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositivePlaneAngleMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositiveRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcSpecularRoughness_WR1: + SCOPE = "type" + TYPE_NAME = "IfcSpecularRoughness" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTextAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['left','right','center','justify'] + + + + + +class IfcTextDecoration_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextDecoration" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['none','underline','overline','line-through','blink'] + + + + + + + + + + + + + + +class IfcTextTransformation_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextTransformation" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['capitalize','uppercase','lowercase','none'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcActorRole_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcActorRole" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + role = self.Role + + assert (role != IfcRoleEnum.USERDEFINED) or ((role == IfcRoleEnum.USERDEFINED) and exists(self.UserDefinedRole)) + + + + + +class IfcActuator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcActuator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcactuatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcActuatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + purpose = self.Purpose + + assert (not exists(purpose)) or ((purpose != IfcAddressTypeEnum.USERDEFINED) or ((purpose == IfcAddressTypeEnum.USERDEFINED) and exists(self.UserDefinedPurpose))) + + + + + +class IfcAdvancedBrep_HasAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrep" + RULE_NAME = "HasAdvancedFaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([afs for afs in self.Outer.CfsFaces if not 'ifc4x1.ifcadvancedface' in typeof(afs)])) == 0 + + + + + +class IfcAdvancedBrepWithVoids_VoidsHaveAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrepWithVoids" + RULE_NAME = "VoidsHaveAdvancedFaces" + + @staticmethod + def __call__(self): + voids = self.Voids + + assert (sizeof([vsh for vsh in voids if (sizeof([afs for afs in vsh.CfsFaces if not 'ifc4x1.ifcadvancedface' in typeof(afs)])) == 0])) == 0 + + + + + +class IfcAdvancedFace_ApplicableSurface: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableSurface" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x1.ifcelementarysurface','ifc4x1.ifcsweptsurface','ifc4x1.ifcbsplinesurface'] * typeof(self.FaceSurface))) == 1 + + + + +class IfcAdvancedFace_RequiresEdgeCurve: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "RequiresEdgeCurve" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x1.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not 'ifc4x1.ifcedgecurve' in typeof(oe.EdgeElement)])) == 0])) == 0 + + + + +class IfcAdvancedFace_ApplicableEdgeCurves: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableEdgeCurves" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x1.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not (sizeof(['ifc4x1.ifcline','ifc4x1.ifcconic','ifc4x1.ifcpolyline','ifc4x1.ifcbsplinecurve'] * typeof(oe.EdgeElement.EdgeGeometry))) == 1])) == 0])) == 0 + + + + + +class IfcAirTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcairterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminalBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcairterminalboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirToAirHeatRecovery_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirToAirHeatRecovery_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcairtoairheatrecoverytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirToAirHeatRecoveryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecoveryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAlarm_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAlarm_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcalarmtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAlarmType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarmType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcApproval_HasIdentifierOrName: + SCOPE = "entity" + TYPE_NAME = "IfcApproval" + RULE_NAME = "HasIdentifierOrName" + + @staticmethod + def __call__(self): + identifier = self.Identifier + name = self.Name + + assert exists(identifier) or exists(name) + + + + + + + + +class IfcArbitraryClosedProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert outercurve.Dim == 2 + + + + +class IfcArbitraryClosedProfileDef_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x1.ifcline' in typeof(outercurve) + + + + +class IfcArbitraryClosedProfileDef_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x1.ifcoffsetcurve2d' in typeof(outercurve) + + + + + +class IfcArbitraryOpenProfileDef_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert ('ifc4x1.ifccenterlineprofiledef' in typeof(self)) or (self.ProfileType == IfcProfileTypeEnum.CURVE) + + + + +class IfcArbitraryOpenProfileDef_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + curve = self.Curve + + assert curve.Dim == 2 + + + + + +class IfcArbitraryProfileDefWithVoids_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == area + + + + +class IfcArbitraryProfileDefWithVoids_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if temp.Dim != 2])) == 0 + + + + +class IfcArbitraryProfileDefWithVoids_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if 'ifc4x1.ifcline' in typeof(temp)])) == 0 + + + + + + + + +class IfcAsymmetricIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + bottomflangethickness = self.BottomFlangeThickness + topflangethickness = self.TopFlangeThickness + + assert (not exists(topflangethickness)) or ((bottomflangethickness + topflangethickness) < overalldepth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + + assert (webthickness < bottomflangewidth) and (webthickness < topflangewidth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidBottomFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidBottomFilletRadius" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + bottomflangefilletradius = self.BottomFlangeFilletRadius + + assert (not exists(bottomflangefilletradius)) or (bottomflangefilletradius <= ((bottomflangewidth - webthickness) / 2.)) + + + + +class IfcAsymmetricIShapeProfileDef_ValidTopFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidTopFilletRadius" + + @staticmethod + def __call__(self): + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + topflangefilletradius = self.TopFlangeFilletRadius + + assert (not exists(topflangefilletradius)) or (topflangefilletradius <= ((topflangewidth - webthickness) / 2.)) + + + + + +class IfcAudioVisualAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAudioVisualAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcaudiovisualappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAudioVisualApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAxis1Placement_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis1Placement_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +def calc_IfcAxis1Placement_Z(self): + axis = self.Axis + return \ + nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + + + + +class IfcAxis2Placement2D_RefDirIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "RefDirIs2D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 2) + + + + +class IfcAxis2Placement2D_LocationIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIs2D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 2 + + + + +def calc_IfcAxis2Placement2D_P(self): + refdirection = self.RefDirection + return \ + IfcBuild2Axes(refdirection) + + + + +class IfcAxis2Placement3D_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis2Placement3D_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis2Placement3D_RefDirIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "RefDirIs3D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 3) + + + + +class IfcAxis2Placement3D_AxisToRefDirPosition: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisToRefDirPosition" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + +class IfcAxis2Placement3D_AxisAndRefDirProvision: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisAndRefDirProvision" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert not exists(axis) ^ exists(refdirection) + + + + +def calc_IfcAxis2Placement3D_P(self): + axis = self.Axis + refdirection = self.RefDirection + return \ + IfcBuildAxes(axis,refdirection) + + + + +class IfcBSplineCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + controlpointslist = self.ControlPointsList + + assert (sizeof([temp for temp in controlpointslist if temp.Dim != (controlpointslist[1 - 1].Dim)])) == 0 + + + + +def calc_IfcBSplineCurve_UpperIndexOnControlPoints(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineCurve_ControlPoints(self): + controlpointslist = self.ControlPointsList + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + return \ + IfcListToArray(controlpointslist,0,upperindexoncontrolpoints) + + + + +class IfcBSplineCurveWithKnots_ConsistentBSpline: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "ConsistentBSpline" + + @staticmethod + def __call__(self): + degree = self.Degree + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + knotmultiplicities = self.KnotMultiplicities + knots = self.Knots + upperindexonknots = self.UpperIndexOnKnots + + assert IfcConstraintsParamBSpline(degree,upperindexonknots,upperindexoncontrolpoints,knotmultiplicities,knots) + + + + +class IfcBSplineCurveWithKnots_CorrespondingKnotLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "CorrespondingKnotLists" + + @staticmethod + def __call__(self): + knotmultiplicities = self.KnotMultiplicities + upperindexonknots = self.UpperIndexOnKnots + + assert sizeof(knotmultiplicities) == upperindexonknots + + + + +def calc_IfcBSplineCurveWithKnots_UpperIndexOnKnots(self): + knots = self.Knots + return \ + sizeof(knots) + + + + +def calc_IfcBSplineSurface_UUpper(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineSurface_VUpper(self): + controlpointslist = self.ControlPointsList + return \ + (sizeof(controlpointslist[1 - 1])) - 1 + + + +def calc_IfcBSplineSurface_ControlPoints(self): + controlpointslist = self.ControlPointsList + uupper = self.UUpper + vupper = self.VUpper + return \ + IfcMakeArrayOfArray(controlpointslist,0,uupper,0,vupper) + + + + +class IfcBSplineSurfaceWithKnots_UDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "UDirectionConstraints" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + uknots = self.UKnots + knotuupper = self.KnotUUpper + + assert IfcConstraintsParamBSpline(self.UDegree,knotuupper,self.UUpper,umultiplicities,uknots) + + + + +class IfcBSplineSurfaceWithKnots_VDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "VDirectionConstraints" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + vknots = self.VKnots + knotvupper = self.KnotVUpper + + assert IfcConstraintsParamBSpline(self.VDegree,knotvupper,self.VUpper,vmultiplicities,vknots) + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingULists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingULists" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + knotuupper = self.KnotUUpper + + assert sizeof(umultiplicities) == knotuupper + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingVLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingVLists" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + knotvupper = self.KnotVUpper + + assert sizeof(vmultiplicities) == knotvupper + + + + +def calc_IfcBSplineSurfaceWithKnots_KnotVUpper(self): + vknots = self.VKnots + return \ + sizeof(vknots) + + + +def calc_IfcBSplineSurfaceWithKnots_KnotUUpper(self): + uknots = self.UKnots + return \ + sizeof(uknots) + + + + +class IfcBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBeamStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcBeamStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x1.ifcrelassociates.relatedobjects') if ('ifc4x1.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x1.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBlobTexture_SupportedRasterFormat: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "SupportedRasterFormat" + + @staticmethod + def __call__(self): + + + assert self.RasterFormat in ['bmp','jpg','gif','png'] + + + + +class IfcBlobTexture_RasterCodeByteStream: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "RasterCodeByteStream" + + @staticmethod + def __call__(self): + rastercode = self.RasterCode + + assert (blength(rastercode) % 8) == 0 + + + + + + + + +class IfcBoiler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBoiler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcboilertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBoilerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoilerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBooleanClippingResult_FirstOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "FirstOperandType" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert ('ifc4x1.ifcsweptareasolid' in typeof(firstoperand)) or ('ifc4x1.ifcsweptdiscsolid' in typeof(firstoperand)) or ('ifc4x1.ifcbooleanclippingresult' in typeof(firstoperand)) + + + + +class IfcBooleanClippingResult_SecondOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "SecondOperandType" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert 'ifc4x1.ifchalfspacesolid' in typeof(secondoperand) + + + + +class IfcBooleanClippingResult_OperatorType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "OperatorType" + + @staticmethod + def __call__(self): + operator = self.Operator + + assert operator == difference + + + + + +class IfcBooleanResult_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + secondoperand = self.SecondOperand + + assert firstoperand.Dim == secondoperand.Dim + + + + +class IfcBooleanResult_FirstOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "FirstOperandClosed" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert (not 'ifc4x1.ifctessellatedfaceset' in typeof(firstoperand)) or (exists(firstoperand.Closed) and firstoperand.Closed) + + + + +class IfcBooleanResult_SecondOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SecondOperandClosed" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert (not 'ifc4x1.ifctessellatedfaceset' in typeof(secondoperand)) or (exists(secondoperand.Closed) and secondoperand.Closed) + + + + +def calc_IfcBooleanResult_Dim(self): + firstoperand = self.FirstOperand + return \ + firstoperand.Dim + + + + + + + +class IfcBoundaryCurve_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBoundaryCurve" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + + + assert self.ClosedCurve + + + + + + + + + + + + + + + + + + + + + + + +def calc_IfcBoundingBox_Dim(self): + + return \ + 3 + + + + +class IfcBoxedHalfSpace_UnboundedSurface: + SCOPE = "entity" + TYPE_NAME = "IfcBoxedHalfSpace" + RULE_NAME = "UnboundedSurface" + + @staticmethod + def __call__(self): + + + assert not 'ifc4x1.ifccurveboundedplane' in typeof(self.BaseSurface) + + + + + + + + +class IfcBuildingElement_MaxOneMaterialAssociation: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElement" + RULE_NAME = "MaxOneMaterialAssociation" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.HasAssociations if 'ifc4x1.ifcrelassociatesmaterial' in typeof(temp)])) <= 1 + + + + + +class IfcBuildingElementPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementPart_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcbuildingelementparttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementPartType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPartType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBuildingElementProxy_HasObjectName: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "HasObjectName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcBuildingElementProxy_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementProxy_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcbuildingelementproxytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementProxyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcBurner_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBurner_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcburnertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBurnerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurnerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCShapeProfileDef_ValidGirth: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidGirth" + + @staticmethod + def __call__(self): + depth = self.Depth + girth = self.Girth + + assert girth < (depth / 2.) + + + + +class IfcCShapeProfileDef_ValidInternalFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidInternalFilletRadius" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + internalfilletradius = self.InternalFilletRadius + + assert (not exists(internalfilletradius)) or ((internalfilletradius <= ((width / 2.) - wallthickness)) and (internalfilletradius <= ((depth / 2.) - wallthickness))) + + + + +class IfcCShapeProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + + assert (wallthickness < (width / 2.)) and (wallthickness < (depth / 2.)) + + + + + +class IfcCableCarrierFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifccablecarrierfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableCarrierSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifccablecarriersegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifccablefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifccablesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCartesianPoint_CP2Dor3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianPoint" + RULE_NAME = "CP2Dor3D" + + @staticmethod + def __call__(self): + coordinates = self.Coordinates + + assert hiindex(coordinates) >= 2 + + + + +def calc_IfcCartesianPoint_Dim(self): + coordinates = self.Coordinates + return \ + hiindex(coordinates) + + + + +def calc_IfcCartesianPointList_Dim(self): + + return \ + IfcPointListDim(self) + + + + + + + + + + +class IfcCartesianTransformationOperator_ScaleGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator" + RULE_NAME = "ScaleGreaterZero" + + @staticmethod + def __call__(self): + scl = self.Scl + + assert scl > 0.0 + + + + +def calc_IfcCartesianTransformationOperator_Scl(self): + scale = self.Scale + return \ + nvl(scale,1.0) + + + +def calc_IfcCartesianTransformationOperator_Dim(self): + localorigin = self.LocalOrigin + return \ + localorigin.Dim + + + + +class IfcCartesianTransformationOperator2D_DimEqual2: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "DimEqual2" + + @staticmethod + def __call__(self): + + + assert self.Dim == 2 + + + + +class IfcCartesianTransformationOperator2D_Axis1Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis1Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 2) + + + + +class IfcCartesianTransformationOperator2D_Axis2Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis2Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 2) + + + + +def calc_IfcCartesianTransformationOperator2D_U(self): + + return \ + IfcBaseAxis(2,self.Axis1,self.Axis2,None) + + + + +class IfcCartesianTransformationOperator2DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator2DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + + +class IfcCartesianTransformationOperator3D_DimIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "DimIs3D" + + @staticmethod + def __call__(self): + + + assert self.Dim == 3 + + + + +class IfcCartesianTransformationOperator3D_Axis1Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis1Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis2Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis2Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis3Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis3Is3D" + + @staticmethod + def __call__(self): + axis3 = self.Axis3 + + assert (not exists(axis3)) or (axis3.Dim == 3) + + + + +def calc_IfcCartesianTransformationOperator3D_U(self): + axis3 = self.Axis3 + return \ + IfcBaseAxis(3,self.Axis1,self.Axis2,axis3) + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale3GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale3GreaterZero" + + @staticmethod + def __call__(self): + scl3 = self.Scl3 + + assert scl3 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl3(self): + scale3 = self.Scale3 + return \ + nvl(scale3,self.Scl) + + + + + + + +class IfcChiller_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChiller_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcchillertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChillerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChillerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcChimney_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChimney_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcchimneytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChimneyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimneyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcCircleHollowProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCircleHollowProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert wallthickness < self.Radius + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoil_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifccoiltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoilType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoilType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcColumn_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcColumn_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifccolumntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcColumnStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcColumnStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x1.ifcrelassociates.relatedobjects') if ('ifc4x1.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x1.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcColumnType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumnType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifccommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcComplexProperty_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert (sizeof([temp for temp in hasproperties if self == temp])) == 0 + + + + +class IfcComplexProperty_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + +class IfcComplexPropertyTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + +class IfcComplexPropertyTemplate_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert (sizeof([temp for temp in haspropertytemplates if self == temp])) == 0 + + + + + +class IfcCompositeCurve_CurveContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "CurveContinuous" + + @staticmethod + def __call__(self): + segments = self.Segments + closedcurve = self.ClosedCurve + + assert ((not closedcurve) and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 1)) or (closedcurve and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 0)) + + + + +class IfcCompositeCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (sizeof([temp for temp in segments if temp.Dim != (segments[1 - 1].Dim)])) == 0 + + + + +def calc_IfcCompositeCurve_NSegments(self): + segments = self.Segments + return \ + sizeof(segments) + + + +def calc_IfcCompositeCurve_ClosedCurve(self): + segments = self.Segments + nsegments = self.NSegments + return \ + (segments[nsegments - 1].Transition) != discontinuous + + + + +class IfcCompositeCurveOnSurface_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveOnSurface" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + + assert sizeof(basissurface) > 0 + + + + +def calc_IfcCompositeCurveOnSurface_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + +class IfcCompositeCurveSegment_ParentIsBoundedCurve: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveSegment" + RULE_NAME = "ParentIsBoundedCurve" + + @staticmethod + def __call__(self): + parentcurve = self.ParentCurve + + assert 'ifc4x1.ifcboundedcurve' in typeof(parentcurve) + + + + +def calc_IfcCompositeCurveSegment_Dim(self): + parentcurve = self.ParentCurve + return \ + parentcurve.Dim + + + + +class IfcCompositeProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if temp.ProfileType != (profiles[1 - 1].ProfileType)])) == 0 + + + + +class IfcCompositeProfileDef_NoRecursion: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "NoRecursion" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if 'ifc4x1.ifccompositeprofiledef' in typeof(temp)])) == 0 + + + + + +class IfcCompressor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCompressor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifccompressortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCompressorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCondenser_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCondenser_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifccondensertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCondenserType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenserType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcConstraint_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcConstraint" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + constraintgrade = self.ConstraintGrade + + assert (constraintgrade != IfcConstraintEnum.USERDEFINED) or ((constraintgrade == IfcConstraintEnum.USERDEFINED) and exists(self.UserDefinedGrade)) + + + + + +class IfcConstructionEquipmentResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionEquipmentResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionMaterialResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionMaterialResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionProductResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionProductResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + + + + + + + + + + + + + +class IfcController_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcController_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifccontrollertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcControllerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcControllerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcCooledBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCooledBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifccooledbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCooledBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCoolingTower_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoolingTower_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifccoolingtowertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoolingTowerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTowerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + +class IfcCovering_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCovering_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifccoveringtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoveringType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoveringType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCrewResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcCrewResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +def calc_IfcCsgPrimitive3D_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcCurtainWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCurtainWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifccurtainwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCurtainWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcCurve_Dim(self): + + return \ + IfcCurveDim(self) + + + + + + + + + + + + + +class IfcCurveStyle_MeasureOfWidth: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "MeasureOfWidth" + + @staticmethod + def __call__(self): + curvewidth = self.CurveWidth + + assert (not exists(curvewidth)) or ('ifc4x1.ifcpositivelengthmeasure' in typeof(curvewidth)) or (('ifc4x1.ifcdescriptivemeasure' in typeof(curvewidth)) and (curvewidth == 'bylayer')) + + + + +class IfcCurveStyle_IdentifiableCurveStyle: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "IdentifiableCurveStyle" + + @staticmethod + def __call__(self): + curvefont = self.CurveFont + curvewidth = self.CurveWidth + curvecolour = self.CurveColour + + assert exists(curvefont) or exists(curvewidth) or exists(curvecolour) + + + + + + + + + + + +class IfcCurveStyleFontPattern_VisibleLengthGreaterEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyleFontPattern" + RULE_NAME = "VisibleLengthGreaterEqualZero" + + @staticmethod + def __call__(self): + visiblesegmentlength = self.VisibleSegmentLength + + assert visiblesegmentlength >= 0. + + + + + + + + +class IfcDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDerivedProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + parentprofile = self.ParentProfile + + assert self.ProfileType == parentprofile.ProfileType + + + + + +class IfcDerivedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof(elements) > 1) or ((sizeof(elements) == 1) and ((elements[1 - 1].Exponent) != 1)) + + + + +class IfcDerivedUnit_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + unittype = self.UnitType + + assert (unittype != IfcDerivedUnitEnum.USERDEFINED) or ((unittype == IfcDerivedUnitEnum.USERDEFINED) and exists(self.UserDefinedType)) + + + + +def calc_IfcDerivedUnit_Dimensions(self): + elements = self.Elements + return \ + IfcDeriveDimensionalExponents(elements) + + + + + + + + + + +class IfcDirection_MagnitudeGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcDirection" + RULE_NAME = "MagnitudeGreaterZero" + + @staticmethod + def __call__(self): + directionratios = self.DirectionRatios + + assert (sizeof([tmp for tmp in directionratios if tmp != 0.0])) > 0 + + + + +def calc_IfcDirection_Dim(self): + directionratios = self.DirectionRatios + return \ + hiindex(directionratios) + + + + +class IfcDiscreteAccessory_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDiscreteAccessory_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcdiscreteaccessorytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDiscreteAccessoryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessoryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcDistributionChamberElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionChamberElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcdistributionchamberelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionChamberElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDocumentReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDocumentReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + name = self.Name + referenceddocument = self.ReferencedDocument + + assert exists(name) ^ exists(referenceddocument) + + + + + +class IfcDoor_CorrectStyleAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectStyleAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcdoortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDoorLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcDoorLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + thresholddepth = self.ThresholdDepth + thresholdthickness = self.ThresholdThickness + + assert not exists(thresholddepth) and (not exists(thresholdthickness)) + + + + +class IfcDoorLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + transomthickness = self.TransomThickness + transomoffset = self.TransomOffset + + assert (exists(transomoffset) and exists(transomthickness)) ^ ((not exists(transomoffset)) and (not exists(transomthickness))) + + + + +class IfcDoorLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + casingthickness = self.CasingThickness + casingdepth = self.CasingDepth + + assert (exists(casingdepth) and exists(casingthickness)) ^ ((not exists(casingdepth)) and (not exists(casingthickness))) + + + + +class IfcDoorLiningProperties_WR35: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR35" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x1.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x1.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcDoorPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x1.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x1.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + + + + + + + +class IfcDoorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDoorTypeEnum.USERDEFINED) or ((predefinedtype == IfcDoorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDraughtingPreDefinedColour_PreDefinedColourNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedColour" + RULE_NAME = "PreDefinedColourNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['black','red','green','blue','yellow','magenta','cyan','white','bylayer'] + + + + + +class IfcDraughtingPreDefinedCurveFont_PreDefinedCurveFontNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedCurveFont" + RULE_NAME = "PreDefinedCurveFontNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['continuous','chain','chaindoubledash','dashed','dotted','bylayer'] + + + + + +class IfcDuctFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcductfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcductsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSilencer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSilencer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcductsilencertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSilencerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcEdgeLoop_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + edgelist = self.EdgeList + ne = self.Ne + + assert (edgelist[1 - 1].EdgeStart) == (edgelist[ne - 1].EdgeEnd) + + + + +class IfcEdgeLoop_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcLoopHeadToTail(self) + + + + +def calc_IfcEdgeLoop_Ne(self): + edgelist = self.EdgeList + return \ + sizeof(edgelist) + + + + +class IfcElectricAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcelectricappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcelectricdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowStorageDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowStorageDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcelectricflowstoragedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowStorageDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricGenerator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricGenerator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcelectricgeneratortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricGeneratorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGeneratorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricMotor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricMotor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcelectricmotortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricMotorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricTimeControl_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricTimeControl_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcelectrictimecontroltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricTimeControlType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControlType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcElementAssembly_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElementAssembly_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcelementassemblytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElementAssemblyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssemblyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcElementQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcElementQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + quantities = self.Quantities + + assert IfcUniqueQuantityNames(quantities) + + + + + + + + + + + + + + + + + + + + + + + +class IfcEngine_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEngine_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcenginetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEngineType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngineType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporativeCooler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporativeCooler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcevaporativecoolertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporativeCoolerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCoolerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcevaporatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvent_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvent_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (not exists(eventtriggertype)) or (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + +class IfcEventType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + +class IfcEventType_CorrectEventTriggerType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectEventTriggerType" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + + + + +class IfcExternalReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcExternalReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + location = self.Location + identification = self.Identification + name = self.Name + + assert exists(identification) or exists(location) or exists(name) + + + + + + + + + + + + + + + + + + + + + + + +class IfcExtrudedAreaSolid_ValidExtrusionDirection: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolid" + RULE_NAME = "ValidExtrusionDirection" + + @staticmethod + def __call__(self): + + + assert IfcDotProduct(IfcDirection(DirectionRatios=[0.0,0.0,1.0]),self.ExtrudedDirection) != 0.0 + + + + + +class IfcExtrudedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + +class IfcFace_HasOuterBound: + SCOPE = "entity" + TYPE_NAME = "IfcFace" + RULE_NAME = "HasOuterBound" + + @staticmethod + def __call__(self): + bounds = self.Bounds + + assert (sizeof([temp for temp in bounds if 'ifc4x1.ifcfaceouterbound' in typeof(temp)])) <= 1 + + + + + +def calc_IfcFaceBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + + + + + + + + + + + + + + + + + + + +class IfcFan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFan_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcfantype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFanType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFanType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcFeatureElementSubtraction_HasNoSubtraction: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "HasNoSubtraction" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasOpenings) == 0 + + + + +class IfcFeatureElementSubtraction_IsNotFilling: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "IsNotFilling" + + @staticmethod + def __call__(self): + + + assert sizeof(self.FillsVoids) == 0 + + + + + +class IfcFillAreaStyle_MaxOneColour: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneColour" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x1.ifccolour' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_MaxOneExtHatchStyle: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneExtHatchStyle" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x1.ifcexternallydefinedhatchstyle' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_ConsistentHatchStyleDef: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "ConsistentHatchStyleDef" + + @staticmethod + def __call__(self): + + + assert IfcCorrectFillAreaStyle(self.FillStyles) + + + + + +class IfcFillAreaStyleHatching_PatternStart2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "PatternStart2D" + + @staticmethod + def __call__(self): + patternstart = self.PatternStart + + assert (not exists(patternstart)) or (patternstart.Dim == 2) + + + + +class IfcFillAreaStyleHatching_RefHatchLine2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "RefHatchLine2D" + + @staticmethod + def __call__(self): + pointofreferencehatchline = self.PointOfReferenceHatchLine + + assert (not exists(pointofreferencehatchline)) or (pointofreferencehatchline.Dim == 2) + + + + + + + + +class IfcFilter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFilter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcfiltertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFilterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFireSuppressionTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFireSuppressionTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcfiresuppressionterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFireSuppressionTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFixedReferenceSweptAreaSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcFixedReferenceSweptAreaSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x1.ifcconic','ifc4x1.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + + + + + + + + + + + + + +class IfcFlowInstrument_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowInstrument_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcflowinstrumenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowInstrumentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrumentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFlowMeter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowMeter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcflowmetertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowMeterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFooting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFooting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcfootingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFootingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFootingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcFurniture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFurniture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcfurnituretype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFurnitureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurnitureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeographicElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcGeographicElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcgeographicelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcGeographicElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeometricCurveSet_NoSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricCurveSet" + RULE_NAME = "NoSurfaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Elements if 'ifc4x1.ifcsurface' in typeof(temp)])) == 0 + + + + + +class IfcGeometricRepresentationContext_North2D: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationContext" + RULE_NAME = "North2D" + + @staticmethod + def __call__(self): + truenorth = self.TrueNorth + + assert (not exists(truenorth)) or (hiindex(truenorth.DirectionRatios) == 2) + + + + + + + + +class IfcGeometricRepresentationSubContext_ParentNoSub: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "ParentNoSub" + + @staticmethod + def __call__(self): + parentcontext = self.ParentContext + + assert not 'ifc4x1.ifcgeometricrepresentationsubcontext' in typeof(parentcontext) + + + + +class IfcGeometricRepresentationSubContext_UserTargetProvided: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "UserTargetProvided" + + @staticmethod + def __call__(self): + targetview = self.TargetView + userdefinedtargetview = self.UserDefinedTargetView + + assert (targetview != IfcGeometricProjectionEnum.USERDEFINED) or ((targetview == IfcGeometricProjectionEnum.USERDEFINED) and exists(userdefinedtargetview)) + + + + +class IfcGeometricRepresentationSubContext_NoCoordOperation: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "NoCoordOperation" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasCoordinateOperation) == 0 + + + + +def calc_IfcGeometricRepresentationSubContext_WorldCoordinateSystem(self): + parentcontext = self.ParentContext + return \ + parentcontext.WorldCoordinateSystem + + + +def calc_IfcGeometricRepresentationSubContext_CoordinateSpaceDimension(self): + parentcontext = self.ParentContext + return \ + parentcontext.CoordinateSpaceDimension + + + +def calc_IfcGeometricRepresentationSubContext_TrueNorth(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.TrueNorth,IfcConvertDirectionInto2D(self.WorldCoordinateSystem.P[2 - 1])) + + + +def calc_IfcGeometricRepresentationSubContext_Precision(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.Precision,1) + + + + +class IfcGeometricSet_ConsistentDim: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricSet" + RULE_NAME = "ConsistentDim" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof([temp for temp in elements if temp.Dim != (elements[1 - 1].Dim)])) == 0 + + + + +def calc_IfcGeometricSet_Dim(self): + elements = self.Elements + return \ + elements[1 - 1].Dim + + + + + + + +class IfcGridAxis_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + axiscurve = self.AxisCurve + + assert axiscurve.Dim == 2 + + + + +class IfcGridAxis_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + partofw = self.PartOfW + partofv = self.PartOfV + partofu = self.PartOfU + + assert (sizeof(partofu) == 1) ^ (sizeof(partofv) == 1) ^ (sizeof(partofw) == 1) + + + + + + + + + + + +def calc_IfcHalfSpaceSolid_Dim(self): + + return \ + 3 + + + + +class IfcHeatExchanger_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHeatExchanger_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcheatexchangertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHeatExchangerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchangerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcHumidifier_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHumidifier_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifchumidifiertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHumidifierType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifierType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + flangethickness = self.FlangeThickness + + assert (2. * flangethickness) < overalldepth + + + + +class IfcIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + webthickness = self.WebThickness + + assert webthickness < overallwidth + + + + +class IfcIShapeProfileDef_ValidFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFilletRadius" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + overalldepth = self.OverallDepth + webthickness = self.WebThickness + flangethickness = self.FlangeThickness + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or ((filletradius <= ((overallwidth - webthickness) / 2.)) and (filletradius <= ((overalldepth - (2. * flangethickness)) / 2.))) + + + + + + + + + + + +class IfcIndexedPolyCurve_Consecutive: + SCOPE = "entity" + TYPE_NAME = "IfcIndexedPolyCurve" + RULE_NAME = "Consecutive" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (sizeof(segments) == 0) or IfcConsecutiveSegments(segments) + + + + + + + + + + + + + + + + + +class IfcInterceptor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcInterceptor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcinterceptortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcInterceptorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIntersectionCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + +class IfcIntersectionCurve_DistinctSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "DistinctSurfaces" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) != (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + + + + + + + + + + + +class IfcJunctionBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcJunctionBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcjunctionboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcJunctionBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcLShapeProfileDef_ValidThickness: + SCOPE = "entity" + TYPE_NAME = "IfcLShapeProfileDef" + RULE_NAME = "ValidThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + thickness = self.Thickness + + assert (thickness < depth) and ((not exists(width)) or (thickness < width)) + + + + + +class IfcLaborResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcLaborResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +class IfcLamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifclamptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcLightFixture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLightFixture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifclightfixturetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLightFixtureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixtureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcLine_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcLine" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + pnt = self.Pnt + dir = self.Dir + + assert dir.Dim == pnt.Dim + + + + + + + + + + + + + + +class IfcLocalPlacement_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcLocalPlacement" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + placementrelto = self.PlacementRelTo + relativeplacement = self.RelativePlacement + + assert IfcCorrectLocalPlacement(relativeplacement,placementrelto) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMaterialDefinitionRepresentation_OnlyStyledRepresentations: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialDefinitionRepresentation" + RULE_NAME = "OnlyStyledRepresentations" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x1.ifcstyledrepresentation' in typeof(temp)])) == 0 + + + + + +class IfcMaterialLayer_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialLayer" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + +def calc_IfcMaterialLayerSet_TotalThickness(self): + + return \ + IfcMlsTotalThickness(self) + + + + + + + + + + + + + +class IfcMaterialProfile_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialProfile" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMechanicalFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMechanicalFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcmechanicalfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMechanicalFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMedicalDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMedicalDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcmedicaldevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMedicalDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMember_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMember_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcmembertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMemberStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcMemberStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x1.ifcrelassociates.relatedobjects') if ('ifc4x1.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x1.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcMemberType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMemberType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcMirroredProfileDef_Operator(self): + + return \ + IfcCartesianTransformationOperator2D(Axis1=IfcDirection(DirectionRatios=[-1.,0.]), Axis2=IfcDirection(DirectionRatios=[0.,1.]), LocalOrigin=IfcCartesianPoint(Coordinates=[0.,0.]), Scale=1.) + + + + + + + +class IfcMotorConnection_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMotorConnection_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcmotorconnectiontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMotorConnectionType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnectionType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcNamedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcNamedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert IfcCorrectDimensions(self.UnitType,self.Dimensions) + + + + + +class IfcObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + isdefinedby = self.IsDefinedBy + + assert (sizeof(isdefinedby) == 0) or IfcUniqueDefinitionNames(isdefinedby) + + + + + + + + + + + +class IfcObjective_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcObjective" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + objectivequalifier = self.ObjectiveQualifier + + assert (objectivequalifier != IfcObjectiveEnum.USERDEFINED) or ((objectivequalifier == IfcObjectiveEnum.USERDEFINED) and exists(self.UserDefinedQualifier)) + + + + + +class IfcOccupant_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcOccupant" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not predefinedtype == IfcOccupantTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcOffsetCurve2D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve2D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 2 + + + + + +class IfcOffsetCurve3D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve3D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 3 + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcOrientedEdge_EdgeElementNotOriented: + SCOPE = "entity" + TYPE_NAME = "IfcOrientedEdge" + RULE_NAME = "EdgeElementNotOriented" + + @staticmethod + def __call__(self): + edgeelement = self.EdgeElement + + assert not 'ifc4x1.ifcorientededge' in typeof(edgeelement) + + + + +def calc_IfcOrientedEdge_EdgeStart(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeStart,edgeelement.EdgeEnd) + + + +def calc_IfcOrientedEdge_EdgeEnd(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeEnd,edgeelement.EdgeStart) + + + + + + + +class IfcOutlet_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcOutlet_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcoutlettype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcOutletType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutletType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcOwnerHistory_CorrectChangeAction: + SCOPE = "entity" + TYPE_NAME = "IfcOwnerHistory" + RULE_NAME = "CorrectChangeAction" + + @staticmethod + def __call__(self): + changeaction = self.ChangeAction + lastmodifieddate = self.LastModifiedDate + + assert exists(lastmodifieddate) or ((not exists(lastmodifieddate)) and (not exists(changeaction))) or ((not exists(lastmodifieddate)) and exists(changeaction) and ((changeaction == IfcChangeActionEnum.NOTDEFINED) or (changeaction == IfcChangeActionEnum.NOCHANGE))) + + + + + + + + +class IfcPath_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcPath" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcPathHeadToTail(self) + + + + + +class IfcPcurve_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcPcurve" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + referencecurve = self.ReferenceCurve + + assert referencecurve.Dim == 2 + + + + + + + + + + + + + + +class IfcPerson_IdentifiablePerson: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "IdentifiablePerson" + + @staticmethod + def __call__(self): + identification = self.Identification + familyname = self.FamilyName + givenname = self.GivenName + + assert exists(identification) or exists(familyname) or exists(givenname) + + + + +class IfcPerson_ValidSetOfNames: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "ValidSetOfNames" + + @staticmethod + def __call__(self): + familyname = self.FamilyName + givenname = self.GivenName + middlenames = self.MiddleNames + + assert (not exists(middlenames)) or exists(familyname) or exists(givenname) + + + + + + + + +class IfcPhysicalComplexQuantity_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert (sizeof([temp for temp in hasquantities if self == temp])) == 0 + + + + +class IfcPhysicalComplexQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert IfcUniqueQuantityNames(hasquantities) + + + + + + + + + + + +class IfcPile_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPile_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcpiletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPileType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPileType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcpipefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcpipesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPixelTexture_MinPixelInS: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInS" + + @staticmethod + def __call__(self): + width = self.Width + + assert width >= 1 + + + + +class IfcPixelTexture_MinPixelInT: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInT" + + @staticmethod + def __call__(self): + height = self.Height + + assert height >= 1 + + + + +class IfcPixelTexture_NumberOfColours: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "NumberOfColours" + + @staticmethod + def __call__(self): + colourcomponents = self.ColourComponents + + assert 1 <= colourcomponents <= 4 + + + + +class IfcPixelTexture_SizeOfPixelList: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "SizeOfPixelList" + + @staticmethod + def __call__(self): + width = self.Width + height = self.Height + pixel = self.Pixel + + assert sizeof(pixel) == (width * height) + + + + +class IfcPixelTexture_PixelAsByteAndSameLength: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "PixelAsByteAndSameLength" + + @staticmethod + def __call__(self): + pixel = self.Pixel + + assert (sizeof([temp for temp in pixel if ((blength(temp) % 8) == 0) and (blength(temp) == (blength(pixel[1 - 1])))])) == sizeof(pixel) + + + + + +def calc_IfcPlacement_Dim(self): + location = self.Location + return \ + location.Dim + + + + + + + + + + + + + +class IfcPlate_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPlate_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcplatetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPlateStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcPlateStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x1.ifcrelassociates.relatedobjects') if ('ifc4x1.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x1.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcPlateType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlateType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcPointOnCurve_Dim(self): + basiscurve = self.BasisCurve + return \ + basiscurve.Dim + + + + +def calc_IfcPointOnSurface_Dim(self): + basissurface = self.BasisSurface + return \ + basissurface.Dim + + + + +class IfcPolyLoop_AllPointsSameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyLoop" + RULE_NAME = "AllPointsSameDim" + + @staticmethod + def __call__(self): + polygon = self.Polygon + + assert (sizeof([temp for temp in polygon if temp.Dim != (polygon[1 - 1].Dim)])) == 0 + + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryDim" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert polygonalboundary.Dim == 2 + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryType: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryType" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert (sizeof(typeof(polygonalboundary) * ['ifc4x1.ifcpolyline','ifc4x1.ifccompositecurve'])) == 1 + + + + + + + + +class IfcPolyline_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyline" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + points = self.Points + + assert (sizeof([temp for temp in points if temp.Dim != (points[1 - 1].Dim)])) == 0 + + + + + + + + +class IfcPositioningElement_HasPlacement: + SCOPE = "entity" + TYPE_NAME = "IfcPositioningElement" + RULE_NAME = "HasPlacement" + + @staticmethod + def __call__(self): + + + assert exists(self.ObjectPlacement) + + + + + +class IfcPostalAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPostalAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + internallocation = self.InternalLocation + addresslines = self.AddressLines + postalbox = self.PostalBox + town = self.Town + region = self.Region + postalcode = self.PostalCode + country = self.Country + + assert exists(internallocation) or exists(addresslines) or exists(postalbox) or exists(postalcode) or exists(town) or exists(region) or exists(country) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPresentationLayerAssignment_ApplicableItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerAssignment" + RULE_NAME = "ApplicableItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x1.ifcshaperepresentation','ifc4x1.ifcgeometricrepresentationitem','ifc4x1.ifcmappeditem'])) == 1])) == sizeof(assigneditems) + + + + + +class IfcPresentationLayerWithStyle_ApplicableOnlyToItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerWithStyle" + RULE_NAME = "ApplicableOnlyToItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x1.ifcgeometricrepresentationitem','ifc4x1.ifcmappeditem'])) >= 1])) == sizeof(assigneditems) + + + + + + + + + + + +class IfcProcedure_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProcedure_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcProcedureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + + + + +class IfcProduct_PlacementForShapeRepresentation: + SCOPE = "entity" + TYPE_NAME = "IfcProduct" + RULE_NAME = "PlacementForShapeRepresentation" + + @staticmethod + def __call__(self): + objectplacement = self.ObjectPlacement + representation = self.Representation + + assert (exists(representation) and exists(objectplacement)) or (exists(representation) and ((sizeof([temp for temp in representation.Representations if 'ifc4x1.ifcshaperepresentation' in typeof(temp)])) == 0)) or (not exists(representation)) + + + + + +class IfcProductDefinitionShape_OnlyShapeModel: + SCOPE = "entity" + TYPE_NAME = "IfcProductDefinitionShape" + RULE_NAME = "OnlyShapeModel" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x1.ifcshapemodel' in typeof(temp)])) == 0 + + + + + + + + + + + + + + +class IfcProject_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProject_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert (not exists(self.RepresentationContexts)) or ((sizeof([temp for temp in self.RepresentationContexts if 'ifc4x1.ifcgeometricrepresentationsubcontext' in typeof(temp)])) == 0) + + + + +class IfcProject_NoDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "NoDecomposition" + + @staticmethod + def __call__(self): + + + assert sizeof(self.Decomposes) == 0 + + + + + + + + + + + +class IfcProjectedCRS_IsLengthUnit: + SCOPE = "entity" + TYPE_NAME = "IfcProjectedCRS" + RULE_NAME = "IsLengthUnit" + + @staticmethod + def __call__(self): + mapunit = self.MapUnit + + assert (not exists(mapunit)) or (mapunit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + + + + + + + + + + + +class IfcPropertyBoundedValue_SameUnitUpperLower: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperLower" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + lowerboundvalue = self.LowerBoundValue + + assert (not exists(upperboundvalue)) or (not exists(lowerboundvalue)) or (typeof(upperboundvalue) == typeof(lowerboundvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitUpperSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperSet" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(upperboundvalue)) or (not exists(setpointvalue)) or (typeof(upperboundvalue) == typeof(setpointvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitLowerSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitLowerSet" + + @staticmethod + def __call__(self): + lowerboundvalue = self.LowerBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(lowerboundvalue)) or (not exists(setpointvalue)) or (typeof(lowerboundvalue) == typeof(setpointvalue)) + + + + + + + + +class IfcPropertyDependencyRelationship_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyDependencyRelationship" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + dependingproperty = self.DependingProperty + dependantproperty = self.DependantProperty + + assert dependingproperty != dependantproperty + + + + + +class IfcPropertyEnumeratedValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeratedValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + enumerationvalues = self.EnumerationValues + enumerationreference = self.EnumerationReference + + assert (not exists(enumerationreference)) or (not exists(enumerationvalues)) or ((sizeof([temp for temp in enumerationvalues if temp in enumerationreference.EnumerationValues])) == sizeof(enumerationvalues)) + + + + + +class IfcPropertyEnumeration_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeration" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.EnumerationValues if not (typeof(self.EnumerationValues[1 - 1])) == typeof(temp)])) == 0 + + + + + +class IfcPropertyListValue_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyListValue" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.ListValues if not (typeof(self.ListValues[1 - 1])) == typeof(temp)])) == 0 + + + + + + + + +class IfcPropertySet_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySet_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + + + + +class IfcPropertySetTemplate_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySetTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + + + + + +class IfcPropertyTableValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + definedvalues = self.DefinedValues + + assert ((not exists(definingvalues)) and (not exists(definedvalues))) or (sizeof(definingvalues) == sizeof(definedvalues)) + + + + +class IfcPropertyTableValue_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + + assert (not exists(definingvalues)) or ((sizeof([temp for temp in self.DefiningValues if typeof(temp) != (typeof(self.DefiningValues[1 - 1]))])) == 0) + + + + +class IfcPropertyTableValue_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + definedvalues = self.DefinedValues + + assert (not exists(definedvalues)) or ((sizeof([temp for temp in self.DefinedValues if typeof(temp) != (typeof(self.DefinedValues[1 - 1]))])) == 0) + + + + + + + + + + + +class IfcProtectiveDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcprotectivedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcprotectivedevicetrippingunittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProtectiveDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProxy_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcProxy" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcPump_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPump_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcpumptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPumpType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPumpType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcQuantityArea_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.AREAUNIT) + + + + +class IfcQuantityArea_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + areavalue = self.AreaValue + + assert areavalue >= 0. + + + + + +class IfcQuantityCount_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityCount" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + countvalue = self.CountValue + + assert countvalue >= 0. + + + + + +class IfcQuantityLength_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + +class IfcQuantityLength_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + lengthvalue = self.LengthValue + + assert lengthvalue >= 0. + + + + + + + + +class IfcQuantityTime_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.TIMEUNIT) + + + + +class IfcQuantityTime_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + timevalue = self.TimeValue + + assert timevalue >= 0. + + + + + +class IfcQuantityVolume_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.VOLUMEUNIT) + + + + +class IfcQuantityVolume_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + volumevalue = self.VolumeValue + + assert volumevalue >= 0. + + + + + +class IfcQuantityWeight_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.MASSUNIT) + + + + +class IfcQuantityWeight_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + weightvalue = self.WeightValue + + assert weightvalue >= 0. + + + + + +class IfcRailing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRailing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcrailingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcramptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRampFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcrampflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRationalBSplineCurveWithKnots_SameNumOfWeightsAndPoints: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "SameNumOfWeightsAndPoints" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert sizeof(weightsdata) == sizeof(self.ControlPointsList) + + + + +class IfcRationalBSplineCurveWithKnots_WeightsGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "WeightsGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcCurveWeightsPositive(self) + + + + +def calc_IfcRationalBSplineCurveWithKnots_Weights(self): + weightsdata = self.WeightsData + return \ + IfcListToArray(weightsdata,0,self.UpperIndexOnControlPoints) + + + + +class IfcRationalBSplineSurfaceWithKnots_CorrespondingWeightsDataLists: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingWeightsDataLists" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert (sizeof(weightsdata) == sizeof(self.ControlPointsList)) and ((sizeof(weightsdata[1 - 1])) == (sizeof(self.ControlPointsList[1 - 1]))) + + + + +class IfcRationalBSplineSurfaceWithKnots_WeightValuesGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "WeightValuesGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcSurfaceWeightsPositive(self) + + + + +def calc_IfcRationalBSplineSurfaceWithKnots_Weights(self): + uupper = self.UUpper + vupper = self.VUpper + weightsdata = self.WeightsData + return \ + IfcMakeArrayOfArray(weightsdata,0,uupper,0,vupper) + + + + +class IfcRectangleHollowProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert (wallthickness < (self.XDim / 2.)) and (wallthickness < (self.YDim / 2.)) + + + + +class IfcRectangleHollowProfileDef_ValidInnerRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidInnerRadius" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + innerfilletradius = self.InnerFilletRadius + + assert (not exists(innerfilletradius)) or ((innerfilletradius <= ((self.XDim / 2.) - wallthickness)) and (innerfilletradius <= ((self.YDim / 2.) - wallthickness))) + + + + +class IfcRectangleHollowProfileDef_ValidOuterRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidOuterRadius" + + @staticmethod + def __call__(self): + outerfilletradius = self.OuterFilletRadius + + assert (not exists(outerfilletradius)) or ((outerfilletradius <= (self.XDim / 2.)) and (outerfilletradius <= (self.YDim / 2.))) + + + + + + + + + + + +class IfcRectangularTrimmedSurface_U1AndU2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "U1AndU2Different" + + @staticmethod + def __call__(self): + u1 = self.U1 + u2 = self.U2 + + assert u1 != u2 + + + + +class IfcRectangularTrimmedSurface_V1AndV2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "V1AndV2Different" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + + assert v1 != v2 + + + + +class IfcRectangularTrimmedSurface_UsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "UsenseCompatible" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + u1 = self.U1 + u2 = self.U2 + usense = self.Usense + + assert (('ifc4x1.ifcelementarysurface' in typeof(basissurface)) and (not 'ifc4x1.ifcplane' in typeof(basissurface))) or ('ifc4x1.ifcsurfaceofrevolution' in typeof(basissurface)) or (usense == (u2 > u1)) + + + + +class IfcRectangularTrimmedSurface_VsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "VsenseCompatible" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + vsense = self.Vsense + + assert vsense == (v2 > v1) + + + + + + + + + + + + + + + + + + + + + + + +class IfcReinforcingBar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingBar_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcreinforcingbartype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingBarType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + +class IfcReinforcingBarType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + + + + + + + + +class IfcReinforcingMesh_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingMesh_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcreinforcingmeshtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingMeshType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + +class IfcReinforcingMeshType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + + +class IfcRelAggregates_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAggregates" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelAssigns_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssigns" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatedobjects = self.RelatedObjects + relatedobjectstype = self.RelatedObjectsType + + assert IfcCorrectObjectAssignment(relatedobjectstype,relatedobjects) + + + + + +class IfcRelAssignsToActor_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToActor" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingactor = self.RelatingActor + + assert (sizeof([temp for temp in self.RelatedObjects if relatingactor == temp])) == 0 + + + + + +class IfcRelAssignsToControl_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToControl" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontrol = self.RelatingControl + + assert (sizeof([temp for temp in self.RelatedObjects if relatingcontrol == temp])) == 0 + + + + + +class IfcRelAssignsToGroup_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToGroup" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatinggroup = self.RelatingGroup + + assert (sizeof([temp for temp in self.RelatedObjects if relatinggroup == temp])) == 0 + + + + + + + + +class IfcRelAssignsToProcess_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProcess" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + + assert (sizeof([temp for temp in self.RelatedObjects if relatingprocess == temp])) == 0 + + + + + +class IfcRelAssignsToProduct_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProduct" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingproduct = self.RelatingProduct + + assert (sizeof([temp for temp in self.RelatedObjects if relatingproduct == temp])) == 0 + + + + + +class IfcRelAssignsToResource_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToResource" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingresource = self.RelatingResource + + assert (sizeof([temp for temp in self.RelatedObjects if relatingresource == temp])) == 0 + + + + + + + + + + + + + + + + + + + + + + + +class IfcRelAssociatesMaterial_NoVoidElement: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "NoVoidElement" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if ('ifc4x1.ifcfeatureelementsubtraction' in typeof(temp)) or ('ifc4x1.ifcvirtualelement' in typeof(temp))])) == 0 + + + + +class IfcRelAssociatesMaterial_AllowedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "AllowedElements" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if (sizeof(typeof(temp) * ['ifc4x1.ifcelement','ifc4x1.ifcelementtype','ifc4x1.ifcwindowstyle','ifc4x1.ifcdoorstyle','ifc4x1.ifcstructuralmember','ifc4x1.ifcport'])) == 0])) == 0 + + + + + + + + +class IfcRelConnectsElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelConnectsPathElements_NormalizedRelatingPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatingPriorities" + + @staticmethod + def __call__(self): + relatingpriorities = self.RelatingPriorities + + assert (sizeof(relatingpriorities) == 0) or ((sizeof([temp for temp in relatingpriorities if 0 <= temp <= 100])) == sizeof(relatingpriorities)) + + + + +class IfcRelConnectsPathElements_NormalizedRelatedPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatedPriorities" + + @staticmethod + def __call__(self): + relatedpriorities = self.RelatedPriorities + + assert (sizeof(relatedpriorities) == 0) or ((sizeof([temp for temp in relatedpriorities if 0 <= temp <= 100])) == sizeof(relatedpriorities)) + + + + + + + + +class IfcRelConnectsPorts_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPorts" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingport = self.RelatingPort + relatedport = self.RelatedPort + + assert relatingport != relatedport + + + + + + + + + + + + + + + + + +class IfcRelContainedInSpatialStructure_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRelContainedInSpatialStructure" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if 'ifc4x1.ifcspatialstructureelement' in typeof(temp)])) == 0 + + + + + + + + + + + +class IfcRelDeclares_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelDeclares" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontext = self.RelatingContext + relateddefinitions = self.RelatedDefinitions + + assert (sizeof([temp for temp in relateddefinitions if relatingcontext == temp])) == 0 + + + + + + + + + + + + + + +class IfcRelDefinesByProperties_NoRelatedTypeObject: + SCOPE = "entity" + TYPE_NAME = "IfcRelDefinesByProperties" + RULE_NAME = "NoRelatedTypeObject" + + @staticmethod + def __call__(self): + + + assert (sizeof([types for types in self.RelatedObjects if 'ifc4x1.ifctypeobject' in typeof(types)])) == 0 + + + + + + + + + + + + + + + + + +class IfcRelInterferesElements_NotSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelInterferesElements" + RULE_NAME = "NotSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelNests_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelNests" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + + + + +class IfcRelReferencedInSpatialStructure_AllowedRelatedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelReferencedInSpatialStructure" + RULE_NAME = "AllowedRelatedElements" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if ('ifc4x1.ifcspatialstructureelement' in typeof(temp)) and (not 'ifc4x1.ifcspace' in typeof(temp))])) == 0 + + + + + +class IfcRelSequence_AvoidInconsistentSequence: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "AvoidInconsistentSequence" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + relatedprocess = self.RelatedProcess + + assert relatingprocess != relatedprocess + + + + +class IfcRelSequence_CorrectSequenceType: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "CorrectSequenceType" + + @staticmethod + def __call__(self): + sequencetype = self.SequenceType + userdefinedsequencetype = self.UserDefinedSequenceType + + assert (sequencetype != IfcSequenceEnum.USERDEFINED) or ((sequencetype == IfcSequenceEnum.USERDEFINED) and exists(userdefinedsequencetype)) + + + + + + + + +class IfcRelSpaceBoundary_CorrectPhysOrVirt: + SCOPE = "entity" + TYPE_NAME = "IfcRelSpaceBoundary" + RULE_NAME = "CorrectPhysOrVirt" + + @staticmethod + def __call__(self): + relatedbuildingelement = self.RelatedBuildingElement + physicalorvirtualboundary = self.PhysicalOrVirtualBoundary + + assert ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Physical) and (not 'ifc4x1.ifcvirtualelement' in typeof(relatedbuildingelement))) or ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Virtual) and (('ifc4x1.ifcvirtualelement' in typeof(relatedbuildingelement)) or ('ifc4x1.ifcopeningelement' in typeof(relatedbuildingelement)))) or (physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.NotDefined) + + + + + + + + + + + + + + + + + +class IfcReparametrisedCompositeCurveSegment_PositiveLengthParameter: + SCOPE = "entity" + TYPE_NAME = "IfcReparametrisedCompositeCurveSegment" + RULE_NAME = "PositiveLengthParameter" + + @staticmethod + def __call__(self): + paramlength = self.ParamLength + + assert paramlength > 0.0 + + + + + + + + + + + + + + +class IfcRepresentationMap_ApplicableMappedRepr: + SCOPE = "entity" + TYPE_NAME = "IfcRepresentationMap" + RULE_NAME = "ApplicableMappedRepr" + + @staticmethod + def __call__(self): + mappedrepresentation = self.MappedRepresentation + + assert 'ifc4x1.ifcshapemodel' in typeof(mappedrepresentation) + + + + + + + + + + + + + + + + + + + + +class IfcRevolvedAreaSolid_AxisStartInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisStartInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Location.Coordinates[3 - 1]) == 0.0 + + + + +class IfcRevolvedAreaSolid_AxisDirectionInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisDirectionInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Z.DirectionRatios[3 - 1]) == 0.0 + + + + +def calc_IfcRevolvedAreaSolid_AxisLine(self): + axis = self.Axis + return \ + IfcLine(Pnt=axis.Location, Dir=IfcVector(Orientation=axis.Z, Magnitude=1.0)) + + + + +class IfcRevolvedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + + + + + + + +class IfcRoof_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRoof_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcrooftype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRoofType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoofType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcRoundedRectangleProfileDef_ValidRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRoundedRectangleProfileDef" + RULE_NAME = "ValidRadius" + + @staticmethod + def __call__(self): + roundingradius = self.RoundingRadius + + assert (roundingradius <= (self.XDim / 2.)) and (roundingradius <= (self.YDim / 2.)) + + + + + +def calc_IfcSIUnit_Dimensions(self): + + return \ + IfcDimensionsForSiUnit(self.Name) + + + + +class IfcSanitaryTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSanitaryTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcsanitaryterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSanitaryTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSeamCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + +class IfcSeamCurve_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) == (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + + + + + + + + +class IfcSectionedSolid_DirectrixIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "DirectrixIs3D" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSectionedSolid_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSolid_SectionsSameType: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "SectionsSameType" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (typeof(crosssections[1 - 1])) != typeof(temp)])) == 0 + + + + + +class IfcSectionedSolidHorizontal_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSolidHorizontal_NoLongitudinalOffsets: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "NoLongitudinalOffsets" + + @staticmethod + def __call__(self): + crosssectionpositions = self.CrossSectionPositions + + assert (sizeof([temp for temp in crosssectionpositions if exists(temp.OffsetLongitudinal)])) == 0 + + + + + +class IfcSectionedSpine_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSpine_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSpine_SpineCurveDim: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "SpineCurveDim" + + @staticmethod + def __call__(self): + spinecurve = self.SpineCurve + + assert spinecurve.Dim == 3 + + + + +def calc_IfcSectionedSpine_Dim(self): + + return \ + 3 + + + + +class IfcSensor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSensor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcsensortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSensorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcShadingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcShadingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcshadingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcShadingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcShapeModel_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcShapeModel" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + ofshapeaspect = self.OfShapeAspect + + assert (sizeof(self.OfProductRepresentation) == 1) ^ (sizeof(self.RepresentationMap) == 1) ^ (sizeof(ofshapeaspect) == 1) + + + + + +class IfcShapeRepresentation_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert 'ifc4x1.ifcgeometricrepresentationcontext' in typeof(self.ContextOfItems) + + + + +class IfcShapeRepresentation_NoTopologicalItem: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "NoTopologicalItem" + + @staticmethod + def __call__(self): + items = self.Items + + assert (sizeof([temp for temp in items if ('ifc4x1.ifctopologicalrepresentationitem' in typeof(temp)) and (not (sizeof(['ifc4x1.ifcvertexpoint','ifc4x1.ifcedgecurve','ifc4x1.ifcfacesurface'] * typeof(temp))) == 1)])) == 0 + + + + +class IfcShapeRepresentation_HasRepresentationType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationType" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcShapeRepresentation_HasRepresentationIdentifier: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationIdentifier" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationIdentifier) + + + + +class IfcShapeRepresentation_CorrectItemsForType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectItemsForType" + + @staticmethod + def __call__(self): + + + assert IfcShapeRepresentationTypes(self.RepresentationType,self.Items) + + + + + +def calc_IfcShellBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + + + + + + + + + + +class IfcSlab_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSlab_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcslabtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSlabElementedCase_HasDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcSlabElementedCase" + RULE_NAME = "HasDecomposition" + + @staticmethod + def __call__(self): + + + assert hiindex(self.IsDecomposedBy) > 0 + + + + + +class IfcSlabStandardCase_HasMaterialLayerSetusage: + SCOPE = "entity" + TYPE_NAME = "IfcSlabStandardCase" + RULE_NAME = "HasMaterialLayerSetusage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x1.ifcrelassociates.relatedobjects') if ('ifc4x1.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x1.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcSlabType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlabType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSolarDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSolarDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcsolardevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSolarDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcSolidModel_Dim(self): + + return \ + 3 + + + + +class IfcSpace_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpace_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcspacetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeater_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpaceHeater_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcspaceheatertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeaterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeaterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSpaceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcSpatialStructureElement_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialStructureElement" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + + + assert (hiindex(self.Decomposes) == 1) and ('ifc4x1.ifcrelaggregates' in (typeof(self.Decomposes[1 - 1]))) and (('ifc4x1.ifcproject' in (typeof(self.Decomposes[1 - 1].RelatingObject))) or ('ifc4x1.ifcspatialstructureelement' in (typeof(self.Decomposes[1 - 1].RelatingObject)))) + + + + + + + + +class IfcSpatialZone_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpatialZone_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcspatialzonetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpatialZoneType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZoneType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcStackTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStackTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcstackterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStackTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStair_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStair_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcstairtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStairFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcstairflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStairType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcStructuralAnalysisModel_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralAnalysisModel" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAnalysisModelTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + + + + +class IfcStructuralCurveAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralCurveAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveAction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert predefinedtype != IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + + + + + + + +class IfcStructuralCurveMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralCurveReaction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveReaction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.SINUS) and (predefinedtype != IfcStructuralCurveActivityTypeEnum.PARABOLA) + + + + + + + + +class IfcStructuralLinearAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x1.ifcstructuralloadlinearforce','ifc4x1.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + +class IfcStructuralLinearAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralCurveActivityTypeEnum.CONST + + + + + + + + +class IfcStructuralLoadCase_IsLoadCasePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadCase" + RULE_NAME = "IsLoadCasePredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcLoadGroupTypeEnum.LOAD_CASE + + + + + +class IfcStructuralLoadConfiguration_ValidListSize: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadConfiguration" + RULE_NAME = "ValidListSize" + + @staticmethod + def __call__(self): + values = self.Values + locations = self.Locations + + assert (not exists(locations)) or (sizeof(locations) == sizeof(values)) + + + + + +class IfcStructuralLoadGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + actiontype = self.ActionType + actionsource = self.ActionSource + + assert ((predefinedtype != IfcLoadGroupTypeEnum.USERDEFINED) and (actiontype != IfcActionTypeEnum.USERDEFINED) and (actionsource != IfcActionSourceTypeEnum.USERDEFINED)) or exists(self.ObjectType) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcStructuralPlanarAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x1.ifcstructuralloadplanarforce','ifc4x1.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + +class IfcStructuralPlanarAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralSurfaceActivityTypeEnum.CONST + + + + + +class IfcStructuralPointAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x1.ifcstructuralloadsingleforce','ifc4x1.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralPointReaction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointReaction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x1.ifcstructuralloadsingleforce','ifc4x1.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralResultGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralResultGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + theorytype = self.TheoryType + + assert (theorytype != IfcAnalysisTheoryTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcStructuralSurfaceAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralSurfaceAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceReaction_HasPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceReaction" + RULE_NAME = "HasPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStyledItem_ApplicableItem: + SCOPE = "entity" + TYPE_NAME = "IfcStyledItem" + RULE_NAME = "ApplicableItem" + + @staticmethod + def __call__(self): + item = self.Item + + assert not 'ifc4x1.ifcstyleditem' in typeof(item) + + + + + +class IfcStyledRepresentation_OnlyStyledItems: + SCOPE = "entity" + TYPE_NAME = "IfcStyledRepresentation" + RULE_NAME = "OnlyStyledItems" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x1.ifcstyleditem' in typeof(temp)])) == 0 + + + + + +class IfcSubContractResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcSubContractResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +def calc_IfcSurface_Dim(self): + + return \ + 3 + + + + +class IfcSurfaceCurve_CurveIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIs3D" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert curve3d.Dim == 3 + + + + +class IfcSurfaceCurve_CurveIsNotPcurve: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIsNotPcurve" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert not 'ifc4x1.ifcpcurve' in typeof(curve3d) + + + + +def calc_IfcSurfaceCurve_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + +class IfcSurfaceCurveSweptAreaSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurveSweptAreaSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x1.ifcconic','ifc4x1.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + +class IfcSurfaceFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSurfaceFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcSurfaceOfLinearExtrusion_DepthGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceOfLinearExtrusion" + RULE_NAME = "DepthGreaterZero" + + @staticmethod + def __call__(self): + depth = self.Depth + + assert depth > 0. + + + + +def calc_IfcSurfaceOfLinearExtrusion_ExtrusionAxis(self): + extrudeddirection = self.ExtrudedDirection + depth = self.Depth + return \ + IfcVector(Orientation=extrudeddirection, Magnitude=depth) + + + + +def calc_IfcSurfaceOfRevolution_AxisLine(self): + axisposition = self.AxisPosition + return \ + IfcLine(Pnt=axisposition.Location, Dir=IfcVector(Orientation=axisposition.Z, Magnitude=1.0)) + + + + +class IfcSurfaceReinforcementArea_SurfaceAndOrShearAreaSpecified: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "SurfaceAndOrShearAreaSpecified" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + surfacereinforcement2 = self.SurfaceReinforcement2 + shearreinforcement = self.ShearReinforcement + + assert exists(surfacereinforcement1) or exists(surfacereinforcement2) or exists(shearreinforcement) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea1: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea1" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + + assert (not exists(surfacereinforcement1)) or (((surfacereinforcement1[1 - 1]) >= 0.) and ((surfacereinforcement1[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement1) == 1) or ((surfacereinforcement1[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea2: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea2" + + @staticmethod + def __call__(self): + surfacereinforcement2 = self.SurfaceReinforcement2 + + assert (not exists(surfacereinforcement2)) or (((surfacereinforcement2[1 - 1]) >= 0.) and ((surfacereinforcement2[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement2) == 1) or ((surfacereinforcement2[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea3: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea3" + + @staticmethod + def __call__(self): + shearreinforcement = self.ShearReinforcement + + assert (not exists(shearreinforcement)) or (shearreinforcement >= 0.) + + + + + +class IfcSurfaceStyle_MaxOneShading: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneShading" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x1.ifcsurfacestyleshading' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneLighting: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneLighting" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x1.ifcsurfacestylelighting' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneRefraction: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneRefraction" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x1.ifcsurfacestylerefraction' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneTextures: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneTextures" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x1.ifcsurfacestylewithtextures' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneExtDefined: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneExtDefined" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x1.ifcexternallydefinedsurfacestyle' in typeof(style)])) <= 1 + + + + + + + + + + + + + + + + + + + + + + + +class IfcSweptAreaSolid_SweptAreaType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptAreaSolid" + RULE_NAME = "SweptAreaType" + + @staticmethod + def __call__(self): + sweptarea = self.SweptArea + + assert sweptarea.ProfileType == IfcProfileTypeEnum.Area + + + + + +class IfcSweptDiskSolid_DirectrixDim: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixDim" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSweptDiskSolid_InnerRadiusSize: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "InnerRadiusSize" + + @staticmethod + def __call__(self): + radius = self.Radius + innerradius = self.InnerRadius + + assert (not exists(innerradius)) or (radius > innerradius) + + + + +class IfcSweptDiskSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x1.ifcconic','ifc4x1.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + +class IfcSweptDiskSolidPolygonal_CorrectRadii: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "CorrectRadii" + + @staticmethod + def __call__(self): + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or (filletradius >= self.Radius) + + + + +class IfcSweptDiskSolidPolygonal_DirectrixIsPolyline: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "DirectrixIsPolyline" + + @staticmethod + def __call__(self): + + + assert ('ifc4x1.ifcpolyline' in typeof(self.Directrix)) or (('ifc4x1.ifcindexedpolycurve' in typeof(self.Directrix)) and (not exists(self.Directrix.Segments))) + + + + + +class IfcSweptSurface_SweptCurveType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptSurface" + RULE_NAME = "SweptCurveType" + + @staticmethod + def __call__(self): + sweptcurve = self.SweptCurve + + assert sweptcurve.ProfileType == IfcProfileTypeEnum.Curve + + + + + +class IfcSwitchingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSwitchingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcswitchingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSwitchingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSystemFurnitureElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSystemFurnitureElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcsystemfurnitureelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSystemFurnitureElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < depth + + + + +class IfcTShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcTable_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + rows = self.Rows + + assert (sizeof([temp for temp in rows if hiindex(temp.RowCells) != (hiindex(rows[1 - 1].RowCells))])) == 0 + + + + +class IfcTable_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + numberofheadings = self.NumberOfHeadings + + assert 0 <= numberofheadings <= 1 + + + + +def calc_IfcTable_NumberOfCellsInRow(self): + rows = self.Rows + return \ + hiindex(rows[1 - 1].RowCells) + + + +def calc_IfcTable_NumberOfHeadings(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if temp.IsHeading]) + + + +def calc_IfcTable_NumberOfDataRows(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if not temp.IsHeading]) + + + + + + + + + + +class IfcTank_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTank_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifctanktype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTankType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTankType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTask_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTask_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcTaskType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTaskType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + +class IfcTelecomAddress_MinimumDataProvided: + SCOPE = "entity" + TYPE_NAME = "IfcTelecomAddress" + RULE_NAME = "MinimumDataProvided" + + @staticmethod + def __call__(self): + telephonenumbers = self.TelephoneNumbers + facsimilenumbers = self.FacsimileNumbers + pagernumber = self.PagerNumber + electronicmailaddresses = self.ElectronicMailAddresses + wwwhomepageurl = self.WWWHomePageURL + messagingids = self.MessagingIDs + + assert exists(telephonenumbers) or exists(facsimilenumbers) or exists(pagernumber) or exists(electronicmailaddresses) or exists(wwwhomepageurl) or exists(messagingids) + + + + + +class IfcTendon_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendon_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifctendontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonAnchor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifctendonanchortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcTessellatedFaceSet_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcTextLiteralWithExtent_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcTextLiteralWithExtent" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + extent = self.Extent + + assert not 'ifc4x1.ifcplanarbox' in typeof(extent) + + + + + + + + +class IfcTextStyleFontModel_MeasureOfFontSize: + SCOPE = "entity" + TYPE_NAME = "IfcTextStyleFontModel" + RULE_NAME = "MeasureOfFontSize" + + @staticmethod + def __call__(self): + + + assert ('ifc4x1.ifclengthmeasure' in typeof(self.FontSize)) and (self.FontSize > 0.) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTopologyRepresentation_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x1.ifctopologicalrepresentationitem' in typeof(temp)])) == 0 + + + + +class IfcTopologyRepresentation_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcTopologyRepresentation_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + + + assert IfcTopologyRepresentationTypes(self.RepresentationType,self.Items) + + + + + +class IfcToroidalSurface_MajorLargerMinor: + SCOPE = "entity" + TYPE_NAME = "IfcToroidalSurface" + RULE_NAME = "MajorLargerMinor" + + @staticmethod + def __call__(self): + majorradius = self.MajorRadius + minorradius = self.MinorRadius + + assert minorradius < majorradius + + + + + +class IfcTransformer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransformer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifctranformertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransformerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcTransportElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransportElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransportElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransportElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifctransportelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransportElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransportElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransportElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcTriangulatedFaceSet_NumberOfTriangles(self): + coordindex = self.CoordIndex + return \ + sizeof(coordindex) + + + + +class IfcTriangulatedIrregularNetwork_NotClosed: + SCOPE = "entity" + TYPE_NAME = "IfcTriangulatedIrregularNetwork" + RULE_NAME = "NotClosed" + + @staticmethod + def __call__(self): + + + assert self.Closed == False + + + + + +class IfcTrimmedCurve_Trim1ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim1ValuesConsistent" + + @staticmethod + def __call__(self): + trim1 = self.Trim1 + + assert (hiindex(trim1) == 1) or ((typeof(trim1[1 - 1])) != (typeof(trim1[2 - 1]))) + + + + +class IfcTrimmedCurve_Trim2ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim2ValuesConsistent" + + @staticmethod + def __call__(self): + trim2 = self.Trim2 + + assert (hiindex(trim2) == 1) or ((typeof(trim2[1 - 1])) != (typeof(trim2[2 - 1]))) + + + + +class IfcTrimmedCurve_NoTrimOfBoundedCurves: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "NoTrimOfBoundedCurves" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert not 'ifc4x1.ifcboundedcurve' in typeof(basiscurve) + + + + + +class IfcTubeBundle_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTubeBundle_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifctubebundletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTubeBundleType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundleType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTypeObject_NameRequired: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "NameRequired" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTypeObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + haspropertysets = self.HasPropertySets + + assert (not exists(haspropertysets)) or IfcUniquePropertySetNames(haspropertysets) + + + + + + + + +class IfcTypeProduct_ApplicableOccurrence: + SCOPE = "entity" + TYPE_NAME = "IfcTypeProduct" + RULE_NAME = "ApplicableOccurrence" + + @staticmethod + def __call__(self): + + + assert (not exists(lambda: self.Types[1 - 1])) or ((sizeof([temp for temp in self.Types[1 - 1].RelatedObjects if not 'ifc4x1.ifcproduct' in typeof(temp)])) == 0) + + + + + + + + +class IfcUShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + +class IfcUShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcUnitAssignment_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcUnitAssignment" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + units = self.Units + + assert IfcCorrectUnitAssignment(units) + + + + + +class IfcUnitaryControlElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryControlElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcunitarycontrolelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryControlElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcUnitaryEquipment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryEquipment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcunitaryequipmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryEquipmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcValve_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcValve_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcvalvetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcValveType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValveType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVector_MagGreaterOrEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcVector" + RULE_NAME = "MagGreaterOrEqualZero" + + @staticmethod + def __call__(self): + magnitude = self.Magnitude + + assert magnitude >= 0.0 + + + + +def calc_IfcVector_Dim(self): + orientation = self.Orientation + return \ + orientation.Dim + + + + + + + + + + + + + +class IfcVibrationIsolator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationIsolator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcvibrationisolatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationIsolatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcVoidingFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcVoidingFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVoidingFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWallElementedCase_HasDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcWallElementedCase" + RULE_NAME = "HasDecomposition" + + @staticmethod + def __call__(self): + + + assert hiindex(self.IsDecomposedBy) > 0 + + + + + +class IfcWallStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcWallStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x1.ifcrelassociates.relatedobjects') if ('ifc4x1.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x1.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWasteTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWasteTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcwasteterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWasteTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWindow_CorrectStyleAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectStyleAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x1.ifcwindowtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWindowLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcWindowLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + firsttransomoffset = self.FirstTransomOffset + secondtransomoffset = self.SecondTransomOffset + + assert not (not exists(firsttransomoffset)) and exists(secondtransomoffset) + + + + +class IfcWindowLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + firstmullionoffset = self.FirstMullionOffset + secondmullionoffset = self.SecondMullionOffset + + assert not (not exists(firstmullionoffset)) and exists(secondmullionoffset) + + + + +class IfcWindowLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x1.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x1.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcWindowPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x1.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x1.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + + + + + + + +class IfcWindowType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWindowTypeEnum.USERDEFINED) or ((predefinedtype == IfcWindowTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWorkCalendar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkCalendar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkCalendarTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkCalendarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcWorkPlan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkPlan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkPlanTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkPlanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcWorkSchedule_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkSchedule" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkScheduleTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkScheduleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcZShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcZShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + + +class IfcZone_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcZone" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof(self.IsGroupedBy) == 0) or ((sizeof([temp for temp in self.IsGroupedBy[1 - 1].RelatedObjects if not ('ifc4x1.ifczone' in typeof(temp)) or ('ifc4x1.ifcspace' in typeof(temp)) or ('ifc4x1.ifcspatialzone' in typeof(temp))])) == 0) + + + + + +class IfcRepresentationContextSameWCS: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcGeometricRepresentationContext = file.by_type("IfcGeometricRepresentationContext") + isdifferent = False + if sizeof(IfcGeometricRepresentationContext) > 1: + for i in range(2, hiindex(IfcGeometricRepresentationContext) + 1): + if (IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem) != (IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem): + isdifferent = (not IfcSameValidPrecision(IfcGeometricRepresentationContext[1 - 1].Precision,IfcGeometricRepresentationContext[i - 1].Precision)) or (not IfcSameAxis2Placement(IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[1 - 1].Precision)) + if isdifferent == True: + break + + assert isdifferent == False + + + + + +class IfcSingleProjectInstance: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcProject = file.by_type("IfcProject") + + + + assert sizeof(IfcProject) <= 1 + + + + +def IfcAssociatedSurface(arg): + + surf = arg.BasisSurface + return surf + + +def IfcBaseAxis(dim, axis1, axis2, axis3): + + + + if dim == 3: + d1 = nvl(IfcNormalise(axis3),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,axis1) + u = [d2,IfcSecondProjAxis(d1,d2,axis2),d1] + else: + if exists(axis1): + d1 = IfcNormalise(axis1) + u = [d1,IfcOrthogonalComplement(d1)] + if exists(axis2): + factor = IfcDotProduct(axis2,u[2 - 1]) + if factor < 0.0: + u[2 - 1].DirectionRatios[1 - 1] = -u[2 - 1].DirectionRatios[1 - 1] + u[2 - 1].DirectionRatios[2 - 1] = -u[2 - 1].DirectionRatios[2 - 1] + else: + if exists(axis2): + d1 = IfcNormalise(axis2) + u = [IfcOrthogonalComplement(d1),d1] + u[1 - 1].DirectionRatios[1 - 1] = -u[1 - 1].DirectionRatios[1 - 1] + u[1 - 1].DirectionRatios[2 - 1] = -u[1 - 1].DirectionRatios[2 - 1] + else: + u = [IfcDirection(DirectionRatios=[1.0,0.0]),IfcDirection(DirectionRatios=[0.0,1.0])] + return u + + +def IfcBooleanChoose(b, choice1, choice2): + + if b: + return choice1 + else: + return choice2 + + +def IfcBuild2Axes(refdirection): + d = nvl(IfcNormalise(refdirection),IfcDirection(DirectionRatios=[1.0,0.0])) + return [d,IfcOrthogonalComplement(d)] + + +def IfcBuildAxes(axis, refdirection): + + d1 = nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,refdirection) + return [d2,IfcNormalise(IfcCrossProduct(d1,d2)).Orientation,d1] + + +def IfcConsecutiveSegments(segments): + result = True + for i in range(1, hiindex(segments) - 1 + 1): + if (segments[i - 1][hiindex(segments[i - 1]) - 1]) != (segments[i - 1][1 - 1]): + result = False + break + return result + + +def IfcConstraintsParamBSpline(degree, upknots, upcp, knotmult, knots): + result = True + + sum = knotmult[1 - 1] + for i in range(2, upknots + 1): + sum = sum + (knotmult[i - 1]) + if (degree < 1) or (upknots < 2) or (upcp < degree) or (sum != (degree + upcp + 2)): + result = False + return result + k = knotmult[1 - 1] + if (k < 1) or (k > (degree + 1)): + result = False + return result + for i in range(2, upknots + 1): + if ((knotmult[i - 1]) < 1) or ((knots[i - 1]) <= (knots[i - 1])): + result = False + return result + k = knotmult[i - 1] + if (i < upknots) and (k > degree): + result = False + return result + if (i == upknots) and (k > (degree + 1)): + result = False + return result + return result + + +def IfcConvertDirectionInto2D(direction): + direction2d = IfcDirection(DirectionRatios=[0.,1.]) + temp = list(direction2d.DirectionRatios) + temp[1 - 1] = direction.DirectionRatios[1 - 1] + direction2d.DirectionRatios = temp + temp = list(direction2d.DirectionRatios) + temp[2 - 1] = direction.DirectionRatios[2 - 1] + direction2d.DirectionRatios = temp + return direction2d + + +def IfcCorrectDimensions(m, dim): + + if m == lengthunit: + if dim == IfcDimensionalExponents(1,0,0,0,0,0,0): + return True + else: + return False + elif m == massunit: + if dim == IfcDimensionalExponents(0,1,0,0,0,0,0): + return True + else: + return False + elif m == timeunit: + if dim == IfcDimensionalExponents(0,0,1,0,0,0,0): + return True + else: + return False + elif m == electriccurrentunit: + if dim == IfcDimensionalExponents(0,0,0,1,0,0,0): + return True + else: + return False + elif m == thermodynamictemperatureunit: + if dim == IfcDimensionalExponents(0,0,0,0,1,0,0): + return True + else: + return False + elif m == amountofsubstanceunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,1,0): + return True + else: + return False + elif m == luminousintensityunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == planeangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == solidangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == areaunit: + if dim == IfcDimensionalExponents(2,0,0,0,0,0,0): + return True + else: + return False + elif m == volumeunit: + if dim == IfcDimensionalExponents(3,0,0,0,0,0,0): + return True + else: + return False + elif m == absorbeddoseunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == radioactivityunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == electriccapacitanceunit: + if dim == IfcDimensionalExponents(-2,-1,4,2,0,0,0): + return True + else: + return False + elif m == doseequivalentunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == electricchargeunit: + if dim == IfcDimensionalExponents(0,0,1,1,0,0,0): + return True + else: + return False + elif m == electricconductanceunit: + if dim == IfcDimensionalExponents(-2,-1,3,2,0,0,0): + return True + else: + return False + elif m == electricvoltageunit: + if dim == IfcDimensionalExponents(2,1,-3,-1,0,0,0): + return True + else: + return False + elif m == electricresistanceunit: + if dim == IfcDimensionalExponents(2,1,-3,-2,0,0,0): + return True + else: + return False + elif m == energyunit: + if dim == IfcDimensionalExponents(2,1,-2,0,0,0,0): + return True + else: + return False + elif m == forceunit: + if dim == IfcDimensionalExponents(1,1,-2,0,0,0,0): + return True + else: + return False + elif m == frequencyunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == inductanceunit: + if dim == IfcDimensionalExponents(2,1,-2,-2,0,0,0): + return True + else: + return False + elif m == illuminanceunit: + if dim == IfcDimensionalExponents(-2,0,0,0,0,0,1): + return True + else: + return False + elif m == luminousfluxunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == magneticfluxunit: + if dim == IfcDimensionalExponents(2,1,-2,-1,0,0,0): + return True + else: + return False + elif m == magneticfluxdensityunit: + if dim == IfcDimensionalExponents(0,1,-2,-1,0,0,0): + return True + else: + return False + elif m == powerunit: + if dim == IfcDimensionalExponents(2,1,-3,0,0,0,0): + return True + else: + return False + elif m == pressureunit: + if dim == IfcDimensionalExponents(-1,1,-2,0,0,0,0): + return True + else: + return False + else: + return unknown + + +def IfcCorrectFillAreaStyle(styles): + hatching = 0 + tiles = 0 + colour = 0 + external = 0 + external = sizeof([style for style in styles if 'ifc4x1.ifcexternallydefinedhatchstyle' in typeof(style)]) + hatching = sizeof([style for style in styles if 'ifc4x1.ifcfillareastylehatching' in typeof(style)]) + tiles = sizeof([style for style in styles if 'ifc4x1.ifcfillareastyletiles' in typeof(style)]) + colour = sizeof([style for style in styles if 'ifc4x1.ifccolour' in typeof(style)]) + if external > 1: + return False + if (external == 1) and ((hatching > 0) or (tiles > 0) or (colour > 0)): + return False + if colour > 1: + return False + if (hatching > 0) and (tiles > 0): + return False + return True + + +def IfcCorrectLocalPlacement(axisplacement, relplacement): + + if exists(relplacement): + if 'ifc4x1.ifcgridplacement' in typeof(relplacement): + return None + if 'ifc4x1.ifclocalplacement' in typeof(relplacement): + if 'ifc4x1.ifcaxis2placement2d' in typeof(axisplacement): + return True + if 'ifc4x1.ifcaxis2placement3d' in typeof(axisplacement): + if relplacement.RelativePlacement.Dim == 3: + return True + else: + return False + return True + return None + + +def IfcCorrectObjectAssignment(constraint, objects): + count = 0 + if not exists(constraint): + return True + if constraint == IfcObjectTypeEnum.NOTDEFINED: + return True + elif constraint == IfcObjectTypeEnum.PRODUCT: + count = sizeof([temp for temp in objects if not 'ifc4x1.ifcproduct' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROCESS: + count = sizeof([temp for temp in objects if not 'ifc4x1.ifcprocess' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.CONTROL: + count = sizeof([temp for temp in objects if not 'ifc4x1.ifccontrol' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.RESOURCE: + count = sizeof([temp for temp in objects if not 'ifc4x1.ifcresource' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.ACTOR: + count = sizeof([temp for temp in objects if not 'ifc4x1.ifcactor' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.GROUP: + count = sizeof([temp for temp in objects if not 'ifc4x1.ifcgroup' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROJECT: + count = sizeof([temp for temp in objects if not 'ifc4x1.ifcproject' in typeof(temp)]) + return count == 0 + else: + return None + + +def IfcCorrectUnitAssignment(units): + namedunitnumber = 0 + derivedunitnumber = 0 + monetaryunitnumber = 0 + namedunitnames = express_set([]) + derivedunitnames = express_set([]) + namedunitnumber = sizeof([temp for temp in units if ('ifc4x1.ifcnamedunit' in typeof(temp)) and (not temp.UnitType == IfcUnitEnum.USERDEFINED)]) + derivedunitnumber = sizeof([temp for temp in units if ('ifc4x1.ifcderivedunit' in typeof(temp)) and (not temp.UnitType == IfcDerivedUnitEnum.USERDEFINED)]) + monetaryunitnumber = sizeof([temp for temp in units if 'ifc4x1.ifcmonetaryunit' in typeof(temp)]) + for i in range(1, sizeof(units) + 1): + if ('ifc4x1.ifcnamedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcUnitEnum.USERDEFINED): + namedunitnames = namedunitnames + (units[i - 1].UnitType) + if ('ifc4x1.ifcderivedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcDerivedUnitEnum.USERDEFINED): + derivedunitnames = derivedunitnames + (units[i - 1].UnitType) + return (sizeof(namedunitnames) == namedunitnumber) and (sizeof(derivedunitnames) == derivedunitnumber) and (monetaryunitnumber <= 1) + + +def IfcCrossProduct(arg1, arg2): + + + + + if ((not exists(arg1)) or (arg1.Dim == 2)) or ((not exists(arg2)) or (arg2.Dim == 2)): + return None + else: + v1 = IfcNormalise(arg1).DirectionRatios + v2 = IfcNormalise(arg2).DirectionRatios + res = IfcDirection(DirectionRatios=[((v1[2 - 1]) * (v2[3 - 1])) - ((v1[3 - 1]) * (v2[2 - 1])),((v1[3 - 1]) * (v2[1 - 1])) - ((v1[1 - 1]) * (v2[3 - 1])),((v1[1 - 1]) * (v2[2 - 1])) - ((v1[2 - 1]) * (v2[1 - 1]))]) + mag = 0.0 + for i in range(1, 3 + 1): + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=arg1, Magnitude=0.0) + return result + + +def IfcCurveDim(curve): + + if 'ifc4x1.ifcline' in typeof(curve): + return curve.Pnt.Dim + if 'ifc4x1.ifcconic' in typeof(curve): + return curve.Position.Dim + if 'ifc4x1.ifcpolyline' in typeof(curve): + return curve.Points[1 - 1].Dim + if 'ifc4x1.ifctrimmedcurve' in typeof(curve): + return IfcCurveDim(curve.BasisCurve) + if 'ifc4x1.ifccompositecurve' in typeof(curve): + return curve.Segments[1 - 1].Dim + if 'ifc4x1.ifcbsplinecurve' in typeof(curve): + return curve.ControlPointsList[1 - 1].Dim + if 'ifc4x1.ifcoffsetcurve2d' in typeof(curve): + return 2 + if 'ifc4x1.ifcoffsetcurve3d' in typeof(curve): + return 3 + if 'ifc4x1.ifcoffsetcurvebydistances' in typeof(curve): + return 3 + if 'ifc4x1.ifccurvesegment2d' in typeof(curve): + return 2 + if 'ifc4x1.ifcalignmentcurve' in typeof(curve): + return 3 + if 'ifc4x1.ifcpcurve' in typeof(curve): + return 3 + if 'ifc4x1.ifcindexedpolycurve' in typeof(curve): + return curve.Points.Dim + return None + + +def IfcCurveWeightsPositive(b): + result = True + for i in range(0, b.UpperIndexOnControlPoints + 1): + if (b.Weights[i - 1]) <= 0.0: + result = False + return result + return result + + +def IfcDeriveDimensionalExponents(unitelements): + result = IfcDimensionalExponents(0,0,0,0,0,0,0) + for i in range(loindex(unitelements), hiindex(unitelements) + 1): + result.LengthExponent = result.LengthExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LengthExponent)) + result.MassExponent = result.MassExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.MassExponent)) + result.TimeExponent = result.TimeExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.TimeExponent)) + result.ElectricCurrentExponent = result.ElectricCurrentExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ElectricCurrentExponent)) + result.ThermodynamicTemperatureExponent = result.ThermodynamicTemperatureExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ThermodynamicTemperatureExponent)) + result.AmountOfSubstanceExponent = result.AmountOfSubstanceExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.AmountOfSubstanceExponent)) + result.LuminousIntensityExponent = result.LuminousIntensityExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LuminousIntensityExponent)) + return result + + +def IfcDimensionsForSiUnit(n): + + if n == metre: + return IfcDimensionalExponents(1,0,0,0,0,0,0) + elif n == square_metre: + return IfcDimensionalExponents(2,0,0,0,0,0,0) + elif n == cubic_metre: + return IfcDimensionalExponents(3,0,0,0,0,0,0) + elif n == gram: + return IfcDimensionalExponents(0,1,0,0,0,0,0) + elif n == second: + return IfcDimensionalExponents(0,0,1,0,0,0,0) + elif n == ampere: + return IfcDimensionalExponents(0,0,0,1,0,0,0) + elif n == kelvin: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == mole: + return IfcDimensionalExponents(0,0,0,0,0,1,0) + elif n == candela: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == radian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == steradian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == hertz: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == newton: + return IfcDimensionalExponents(1,1,-2,0,0,0,0) + elif n == pascal: + return IfcDimensionalExponents(-1,1,-2,0,0,0,0) + elif n == joule: + return IfcDimensionalExponents(2,1,-2,0,0,0,0) + elif n == watt: + return IfcDimensionalExponents(2,1,-3,0,0,0,0) + elif n == coulomb: + return IfcDimensionalExponents(0,0,1,1,0,0,0) + elif n == volt: + return IfcDimensionalExponents(2,1,-3,-1,0,0,0) + elif n == farad: + return IfcDimensionalExponents(-2,-1,4,2,0,0,0) + elif n == ohm: + return IfcDimensionalExponents(2,1,-3,-2,0,0,0) + elif n == siemens: + return IfcDimensionalExponents(-2,-1,3,2,0,0,0) + elif n == weber: + return IfcDimensionalExponents(2,1,-2,-1,0,0,0) + elif n == tesla: + return IfcDimensionalExponents(0,1,-2,-1,0,0,0) + elif n == henry: + return IfcDimensionalExponents(2,1,-2,-2,0,0,0) + elif n == degree_celsius: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == lumen: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == lux: + return IfcDimensionalExponents(-2,0,0,0,0,0,1) + elif n == becquerel: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == gray: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + elif n == sievert: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + else: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + + +def IfcDotProduct(arg1, arg2): + + + + if (not exists(arg1)) or (not exists(arg2)): + scalar = None + else: + if arg1.Dim != arg2.Dim: + scalar = None + else: + vec1 = IfcNormalise(arg1) + vec2 = IfcNormalise(arg2) + ndim = arg1.Dim + scalar = 0.0 + for i in range(1, ndim + 1): + scalar = scalar + ((vec1.DirectionRatios[i - 1]) * (vec2.DirectionRatios[i - 1])) + return scalar + + +def IfcFirstProjAxis(zaxis, arg): + + + + + if not exists(zaxis): + return None + else: + z = IfcNormalise(zaxis) + if not exists(arg): + if z.DirectionRatios != [1.0,0.0,0.0]: + v = IfcDirection(DirectionRatios=[1.0,0.0,0.0]) + else: + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + if arg.Dim != 3: + return None + if IfcCrossProduct(arg,z).Magnitude == 0.0: + return None + else: + v = IfcNormalise(arg) + xvec = IfcScalarTimesVector(IfcDotProduct(v,z),z) + xaxis = IfcVectorDifference(v,xvec).Orientation + xaxis = IfcNormalise(xaxis) + return xaxis + + +def IfcGetBasisSurface(c): + + + surfs = [] + if 'ifc4x1.ifcpcurve' in typeof(c): + surfs = [c.BasisSurface] + else: + if 'ifc4x1.ifcsurfacecurve' in typeof(c): + n = sizeof(c.AssociatedGeometry) + for i in range(1, n + 1): + surfs = surfs + (IfcAssociatedSurface(c.AssociatedGeometry[i - 1])) + if 'ifc4x1.ifccompositecurveonsurface' in typeof(c): + n = sizeof(c.Segments) + surfs = IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve) + if n > 1: + for i in range(2, n + 1): + surfs = surfs * (IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve)) + return surfs + + +def IfcListToArray(lis, low, u): + + + n = sizeof(lis) + if n != (u - low + 1): + return None + else: + res = ([lis[1 - 1]] * n) + for i in range(2, n + 1): + temp = list(res) + temp[low - 1] = lis[i - 1] + res = temp + return res + + +def IfcLoopHeadToTail(aloop): + + p = True + n = sizeof(aloop.EdgeList) + for i in range(2, n + 1): + p = p and ((aloop.EdgeList[i - 1].EdgeEnd) == (aloop.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcMakeArrayOfArray(lis, low1, u1, low2, u2): + + if (u1 - low1 + 1) != sizeof(lis): + return None + if (u2 - low2 + 1) != (sizeof(lis[1 - 1])): + return None + res = ([IfcListToArray(lis[1 - 1],low2,u2)] * u1 - low1 + 1) + for i in range(2, hiindex(lis) + 1): + if (u2 - low2 + 1) != (sizeof(lis[i - 1])): + return None + temp = list(res) + temp[low1 - 1] = IfcListToArray(lis[i - 1],low2,u2) + res = temp + return res + + +def IfcMlsTotalThickness(layerset): + max = layerset.MaterialLayers[1 - 1].LayerThickness + if sizeof(layerset.MaterialLayers) > 1: + for i in range(2, hiindex(layerset.MaterialLayers) + 1): + max = max + (layerset.MaterialLayers[i - 1].LayerThickness) + return max + + +def IfcNormalise(arg): + + v = IfcDirection(DirectionRatios=[1.,0.]) + vec = IfcVector(Orientation=IfcDirection(DirectionRatios=[1.,0.]), Magnitude=1.) + + result = v + if not exists(arg): + return None + else: + if 'ifc4x1.ifcvector' in typeof(arg): + ndim = arg.Dim + v.DirectionRatios = arg.Orientation.DirectionRatios + vec.Magnitude = arg.Magnitude + vec.Orientation = v + if arg.Magnitude == 0.0: + return None + else: + vec.Magnitude = 1.0 + else: + ndim = arg.Dim + v.DirectionRatios = arg.DirectionRatios + mag = 0.0 + for i in range(1, ndim + 1): + mag = mag + ((v.DirectionRatios[i - 1]) * (v.DirectionRatios[i - 1])) + if mag > 0.0: + mag = sqrt(mag) + for i in range(1, ndim + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = (v.DirectionRatios[i - 1]) / mag + v.DirectionRatios = temp + if 'ifc4x1.ifcvector' in typeof(arg): + vec.Orientation = v + result = vec + else: + result = v + else: + return None + return result + + +def IfcOrthogonalComplement(vec): + + if (not exists(vec)) or (vec.Dim != 2): + return None + else: + result = IfcDirection(DirectionRatios=[-vec.DirectionRatios[2 - 1],vec.DirectionRatios[1 - 1]]) + return result + + +def IfcPathHeadToTail(apath): + n = 0 + p = unknown + n = sizeof(apath.EdgeList) + for i in range(2, n + 1): + p = p and ((apath.EdgeList[i - 1].EdgeEnd) == (apath.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcPointListDim(pointlist): + + if 'ifc4x1.ifccartesianpointlist2d' in typeof(pointlist): + return 2 + if 'ifc4x1.ifccartesianpointlist3d' in typeof(pointlist): + return 3 + return None + + +def IfcSameAxis2Placement(ap1, ap2, epsilon): + + return (IfcSameDirection(ap1.P[1 - 1],ap2.P[1 - 1],epsilon)) and (IfcSameDirection(ap1.P[2 - 1],ap2.P[2 - 1],epsilon)) and IfcSameCartesianPoint(ap1.Location,ap1.Location,epsilon) + + +def IfcSameCartesianPoint(cp1, cp2, epsilon): + cp1x = cp1.Coordinates[1 - 1] + cp1y = cp1.Coordinates[2 - 1] + cp1z = 0 + cp2x = cp2.Coordinates[1 - 1] + cp2y = cp2.Coordinates[2 - 1] + cp2z = 0 + if sizeof(cp1.Coordinates) > 2: + cp1z = cp1.Coordinates[3 - 1] + if sizeof(cp2.Coordinates) > 2: + cp2z = cp2.Coordinates[3 - 1] + return IfcSameValue(cp1x,cp2x,epsilon) and IfcSameValue(cp1y,cp2y,epsilon) and IfcSameValue(cp1z,cp2z,epsilon) + + +def IfcSameDirection(dir1, dir2, epsilon): + dir1x = dir1.DirectionRatios[1 - 1] + dir1y = dir1.DirectionRatios[2 - 1] + dir1z = 0 + dir2x = dir2.DirectionRatios[1 - 1] + dir2y = dir2.DirectionRatios[2 - 1] + dir2z = 0 + if sizeof(dir1.DirectionRatios) > 2: + dir1z = dir1.DirectionRatios[3 - 1] + if sizeof(dir2.DirectionRatios) > 2: + dir2z = dir2.DirectionRatios[3 - 1] + return IfcSameValue(dir1x,dir2x,epsilon) and IfcSameValue(dir1y,dir2y,epsilon) and IfcSameValue(dir1z,dir2z,epsilon) + + +def IfcSameValidPrecision(epsilon1, epsilon2): + + defaulteps = 0.000001 + derivationofeps = 1.001 + uppereps = 1.0 + valideps1 = nvl(epsilon1,defaulteps) + valideps2 = nvl(epsilon2,defaulteps) + return (0.0 < valideps1) and (valideps1 <= (derivationofeps * valideps2)) and (valideps2 <= (derivationofeps * valideps1)) and (valideps2 < uppereps) + + +def IfcSameValue(value1, value2, epsilon): + + defaulteps = 0.000001 + valideps = nvl(epsilon,defaulteps) + return ((value1 + valideps) > value2) and (value1 < (value2 + valideps)) + + +def IfcScalarTimesVector(scalar, vec): + + + + if (not exists(scalar)) or (not exists(vec)): + return None + else: + if 'ifc4x1.ifcvector' in typeof(vec): + v = vec.Orientation + mag = scalar * vec.Magnitude + else: + v = vec + mag = scalar + if mag < 0.0: + for i in range(1, sizeof(v.DirectionRatios) + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = -v.DirectionRatios[i - 1] + v.DirectionRatios = temp + mag = -mag + result = IfcVector(Orientation=IfcNormalise(v), Magnitude=mag) + return result + + +def IfcSecondProjAxis(zaxis, xaxis, arg): + + + + if not exists(arg): + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + v = arg + temp = IfcScalarTimesVector(IfcDotProduct(v,zaxis),zaxis) + yaxis = IfcVectorDifference(v,temp) + temp = IfcScalarTimesVector(IfcDotProduct(v,xaxis),xaxis) + yaxis = IfcVectorDifference(yaxis,temp) + yaxis = IfcNormalise(yaxis) + return yaxis.Orientation + + +def IfcShapeRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'point': + count = sizeof([temp for temp in items if 'ifc4x1.ifcpoint' in typeof(temp)]) + elif reptype.lower() == 'pointcloud': + count = sizeof([temp for temp in items if 'ifc4x1.ifccartesianpointlist3d' in typeof(temp)]) + elif reptype.lower() == 'curve': + count = sizeof([temp for temp in items if 'ifc4x1.ifccurve' in typeof(temp)]) + elif reptype.lower() == 'curve2d': + count = sizeof([temp for temp in items if ('ifc4x1.ifccurve' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'curve3d': + count = sizeof([temp for temp in items if ('ifc4x1.ifccurve' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'surface': + count = sizeof([temp for temp in items if 'ifc4x1.ifcsurface' in typeof(temp)]) + elif reptype.lower() == 'surface2d': + count = sizeof([temp for temp in items if ('ifc4x1.ifcsurface' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'surface3d': + count = sizeof([temp for temp in items if ('ifc4x1.ifcsurface' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'fillarea': + count = sizeof([temp for temp in items if 'ifc4x1.ifcannotationfillarea' in typeof(temp)]) + elif reptype.lower() == 'text': + count = sizeof([temp for temp in items if 'ifc4x1.ifctextliteral' in typeof(temp)]) + elif reptype.lower() == 'advancedsurface': + count = sizeof([temp for temp in items if 'ifc4x1.ifcbsplinesurface' in typeof(temp)]) + elif reptype.lower() == 'annotation2d': + count = sizeof([temp for temp in items if (sizeof(typeof(temp) * ['ifc4x1.ifcpoint','ifc4x1.ifccurve','ifc4x1.ifcgeometriccurveset','ifc4x1.ifcannotationfillarea','ifc4x1.ifctextliteral'])) == 1]) + elif reptype.lower() == 'geometricset': + count = sizeof([temp for temp in items if ('ifc4x1.ifcgeometricset' in typeof(temp)) or ('ifc4x1.ifcpoint' in typeof(temp)) or ('ifc4x1.ifccurve' in typeof(temp)) or ('ifc4x1.ifcsurface' in typeof(temp))]) + elif reptype.lower() == 'geometriccurveset': + count = sizeof([temp for temp in items if ('ifc4x1.ifcgeometriccurveset' in typeof(temp)) or ('ifc4x1.ifcgeometricset' in typeof(temp)) or ('ifc4x1.ifcpoint' in typeof(temp)) or ('ifc4x1.ifccurve' in typeof(temp))]) + for i in range(1, hiindex(items) + 1): + if 'ifc4x1.ifcgeometricset' in (typeof(items[i - 1])): + if (sizeof([temp for temp in items[i - 1].Elements if 'ifc4x1.ifcsurface' in typeof(temp)])) > 0: + count = count - 1 + elif reptype.lower() == 'tessellation': + count = sizeof([temp for temp in items if 'ifc4x1.ifctessellateditem' in typeof(temp)]) + elif reptype.lower() == 'surfaceorsolidmodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x1.ifctessellateditem','ifc4x1.ifcshellbasedsurfacemodel','ifc4x1.ifcfacebasedsurfacemodel','ifc4x1.ifcsolidmodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'surfacemodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x1.ifctessellateditem','ifc4x1.ifcshellbasedsurfacemodel','ifc4x1.ifcfacebasedsurfacemodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'solidmodel': + count = sizeof([temp for temp in items if 'ifc4x1.ifcsolidmodel' in typeof(temp)]) + elif reptype.lower() == 'sweptsolid': + count = sizeof([temp for temp in items if ((sizeof(['ifc4x1.ifcextrudedareasolid','ifc4x1.ifcrevolvedareasolid'] * typeof(temp))) >= 1) and ((sizeof(['ifc4x1.ifcextrudedareasolidtapered','ifc4x1.ifcrevolvedareasolidtapered'] * typeof(temp))) == 0)]) + elif reptype.lower() == 'advancedsweptsolid': + count = sizeof([temp for temp in items if (sizeof(['ifc4x1.ifcsweptareasolid','ifc4x1.ifcsweptdisksolid'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'csg': + count = sizeof([temp for temp in items if (sizeof(['ifc4x1.ifcbooleanresult','ifc4x1.ifccsgprimitive3d','ifc4x1.ifccsgsolid'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'clipping': + count = sizeof([temp for temp in items if (sizeof(['ifc4x1.ifccsgsolid','ifc4x1.ifcbooleanclippingresult'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'brep': + count = sizeof([temp for temp in items if 'ifc4x1.ifcfacetedbrep' in typeof(temp)]) + elif reptype.lower() == 'advancedbrep': + count = sizeof([temp for temp in items if 'ifc4x1.ifcmanifoldsolidbrep' in typeof(temp)]) + elif reptype.lower() == 'boundingbox': + count = sizeof([temp for temp in items if 'ifc4x1.ifcboundingbox' in typeof(temp)]) + if sizeof(items) > 1: + count = 0 + elif reptype.lower() == 'sectionedspine': + count = sizeof([temp for temp in items if 'ifc4x1.ifcsectionedspine' in typeof(temp)]) + elif reptype.lower() == 'lightsource': + count = sizeof([temp for temp in items if 'ifc4x1.ifclightsource' in typeof(temp)]) + elif reptype.lower() == 'mappedrepresentation': + count = sizeof([temp for temp in items if 'ifc4x1.ifcmappeditem' in typeof(temp)]) + else: + return None + return count == sizeof(items) + + +def IfcSurfaceWeightsPositive(b): + result = True + weights = b.Weights + for i in range(0, b.UUpper + 1): + for j in range(0, b.VUpper + 1): + if (weights[i - 1][j - 1]) <= 0.0: + result = False + return result + return result + + +def IfcTaperedSweptAreaProfiles(startarea, endarea): + result = False + if 'ifc4x1.ifcparameterizedprofiledef' in typeof(startarea): + if 'ifc4x1.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = typeof(startarea) == typeof(endarea) + else: + if 'ifc4x1.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = False + return result + + +def IfcTopologyRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'vertex': + count = sizeof([temp for temp in items if 'ifc4x1.ifcvertex' in typeof(temp)]) + elif reptype.lower() == 'edge': + count = sizeof([temp for temp in items if 'ifc4x1.ifcedge' in typeof(temp)]) + elif reptype.lower() == 'path': + count = sizeof([temp for temp in items if 'ifc4x1.ifcpath' in typeof(temp)]) + elif reptype.lower() == 'face': + count = sizeof([temp for temp in items if 'ifc4x1.ifcface' in typeof(temp)]) + elif reptype.lower() == 'shell': + count = sizeof([temp for temp in items if ('ifc4x1.ifcopenshell' in typeof(temp)) or ('ifc4x1.ifcclosedshell' in typeof(temp))]) + elif reptype.lower() == 'undefined': + return True + else: + return None + return count == sizeof(items) + + +def IfcUniqueDefinitionNames(relations): + + + properties = express_set([]) + + if sizeof(relations) == 0: + return True + for i in range(1, hiindex(relations) + 1): + definition = relations[i - 1].RelatingPropertyDefinition + if 'ifc4x1.ifcpropertysetdefinition' in typeof(definition): + properties = properties + definition + else: + if 'ifc4x1.ifcpropertysetdefinitionset' in typeof(definition): + definitionset = definition + for j in range(1, hiindex(definitionset) + 1): + properties = properties + (definitionset[j - 1]) + result = IfcUniquePropertySetNames(properties) + return result + + +def IfcUniquePropertyName(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniquePropertySetNames(properties): + names = express_set([]) + unnamed = 0 + for i in range(1, hiindex(properties) + 1): + if 'ifc4x1.ifcpropertyset' in (typeof(properties[i - 1])): + names = names + (properties[i - 1].Name) + else: + unnamed = unnamed + 1 + return (sizeof(names) + unnamed) == sizeof(properties) + + +def IfcUniquePropertyTemplateNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniqueQuantityNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcVectorDifference(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x1.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x1.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) - (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + +def IfcVectorSum(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x1.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x1.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) + (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + diff --git a/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X2.py b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X2.py new file mode 100644 index 0000000000..2dc7f9a78e --- /dev/null +++ b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X2.py @@ -0,0 +1,22456 @@ +import ifcopenshell + +def exists(v): + if callable(v): + try: return v() is not None + except IndexError as e: return False + else: return v is not None + + + +def nvl(v, default): return v if v is not None else default + + +sizeof = len +hiindex = len +blength = len +loindex = lambda x: 1 +from math import * +unknown = 'UNKNOWN' + +def usedin(inst, ref_name): + if inst is None: + return [] + _, __, attr = ref_name.split('.') + def filter(): + for ref, attr_idx in inst.wrapped_data.file.get_inverse(inst, allow_duplicate=True, with_attribute_indices=True): + if ref.wrapped_data.get_attribute_names()[attr_idx].lower() == attr: + yield ref + return list(filter()) + + +class express_set(set): + def __rmul__(self, other): + return express_set(set(other) & self) + def __add__(self, other): + def make_list(v): + # Comply with 12.6.3 Union operator + if isinstance(v, (list, tuple, set, express_set)): + return list(v) + else: + return [v] + return express_set(list(self) + make_list(other)) + __radd__ = __add__ + def __repr__(self): + return repr(set(self)) + + +def typeof(inst): + if not inst: + # If V evaluates to indeterminate (?), an empty set is returned. + return express_set([]) + schema_name = inst.is_a(True).split('.')[0].lower() + def inner(): + decl = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(inst.is_a()) + while decl: + yield '.'.join((schema_name, decl.name().lower())) + decl = decl.supertype() + return express_set(inner()) + +class enum_namespace: + def __getattr__(self, k): + return k.upper() + + +IfcActionRequestTypeEnum = enum_namespace() + + +email = IfcActionRequestTypeEnum.EMAIL + + +fax = IfcActionRequestTypeEnum.FAX + + +phone = IfcActionRequestTypeEnum.PHONE + + +post = IfcActionRequestTypeEnum.POST + + +verbal = IfcActionRequestTypeEnum.VERBAL + + +userdefined = IfcActionRequestTypeEnum.USERDEFINED + + +notdefined = IfcActionRequestTypeEnum.NOTDEFINED + + +IfcActionSourceTypeEnum = enum_namespace() + + +dead_load_g = IfcActionSourceTypeEnum.DEAD_LOAD_G + + +completion_g1 = IfcActionSourceTypeEnum.COMPLETION_G1 + + +live_load_q = IfcActionSourceTypeEnum.LIVE_LOAD_Q + + +snow_s = IfcActionSourceTypeEnum.SNOW_S + + +wind_w = IfcActionSourceTypeEnum.WIND_W + + +prestressing_p = IfcActionSourceTypeEnum.PRESTRESSING_P + + +settlement_u = IfcActionSourceTypeEnum.SETTLEMENT_U + + +temperature_t = IfcActionSourceTypeEnum.TEMPERATURE_T + + +earthquake_e = IfcActionSourceTypeEnum.EARTHQUAKE_E + + +fire = IfcActionSourceTypeEnum.FIRE + + +impulse = IfcActionSourceTypeEnum.IMPULSE + + +impact = IfcActionSourceTypeEnum.IMPACT + + +transport = IfcActionSourceTypeEnum.TRANSPORT + + +erection = IfcActionSourceTypeEnum.ERECTION + + +propping = IfcActionSourceTypeEnum.PROPPING + + +system_imperfection = IfcActionSourceTypeEnum.SYSTEM_IMPERFECTION + + +shrinkage = IfcActionSourceTypeEnum.SHRINKAGE + + +creep = IfcActionSourceTypeEnum.CREEP + + +lack_of_fit = IfcActionSourceTypeEnum.LACK_OF_FIT + + +buoyancy = IfcActionSourceTypeEnum.BUOYANCY + + +ice = IfcActionSourceTypeEnum.ICE + + +current = IfcActionSourceTypeEnum.CURRENT + + +wave = IfcActionSourceTypeEnum.WAVE + + +rain = IfcActionSourceTypeEnum.RAIN + + +brakes = IfcActionSourceTypeEnum.BRAKES + + +userdefined = IfcActionSourceTypeEnum.USERDEFINED + + +notdefined = IfcActionSourceTypeEnum.NOTDEFINED + + +IfcActionTypeEnum = enum_namespace() + + +permanent_g = IfcActionTypeEnum.PERMANENT_G + + +variable_q = IfcActionTypeEnum.VARIABLE_Q + + +extraordinary_a = IfcActionTypeEnum.EXTRAORDINARY_A + + +userdefined = IfcActionTypeEnum.USERDEFINED + + +notdefined = IfcActionTypeEnum.NOTDEFINED + + +IfcActuatorTypeEnum = enum_namespace() + + +electricactuator = IfcActuatorTypeEnum.ELECTRICACTUATOR + + +handoperatedactuator = IfcActuatorTypeEnum.HANDOPERATEDACTUATOR + + +hydraulicactuator = IfcActuatorTypeEnum.HYDRAULICACTUATOR + + +pneumaticactuator = IfcActuatorTypeEnum.PNEUMATICACTUATOR + + +thermostaticactuator = IfcActuatorTypeEnum.THERMOSTATICACTUATOR + + +userdefined = IfcActuatorTypeEnum.USERDEFINED + + +notdefined = IfcActuatorTypeEnum.NOTDEFINED + + +IfcAddressTypeEnum = enum_namespace() + + +office = IfcAddressTypeEnum.OFFICE + + +site = IfcAddressTypeEnum.SITE + + +home = IfcAddressTypeEnum.HOME + + +distributionpoint = IfcAddressTypeEnum.DISTRIBUTIONPOINT + + +userdefined = IfcAddressTypeEnum.USERDEFINED + + +IfcAirTerminalBoxTypeEnum = enum_namespace() + + +constantflow = IfcAirTerminalBoxTypeEnum.CONSTANTFLOW + + +variableflowpressuredependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREDEPENDANT + + +variableflowpressureindependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREINDEPENDANT + + +userdefined = IfcAirTerminalBoxTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalBoxTypeEnum.NOTDEFINED + + +IfcAirTerminalTypeEnum = enum_namespace() + + +diffuser = IfcAirTerminalTypeEnum.DIFFUSER + + +grille = IfcAirTerminalTypeEnum.GRILLE + + +louvre = IfcAirTerminalTypeEnum.LOUVRE + + +register = IfcAirTerminalTypeEnum.REGISTER + + +userdefined = IfcAirTerminalTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalTypeEnum.NOTDEFINED + + +IfcAirToAirHeatRecoveryTypeEnum = enum_namespace() + + +fixedplatecounterflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECOUNTERFLOWEXCHANGER + + +fixedplatecrossflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECROSSFLOWEXCHANGER + + +fixedplateparallelflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATEPARALLELFLOWEXCHANGER + + +rotarywheel = IfcAirToAirHeatRecoveryTypeEnum.ROTARYWHEEL + + +runaroundcoilloop = IfcAirToAirHeatRecoveryTypeEnum.RUNAROUNDCOILLOOP + + +heatpipe = IfcAirToAirHeatRecoveryTypeEnum.HEATPIPE + + +twintowerenthalpyrecoveryloops = IfcAirToAirHeatRecoveryTypeEnum.TWINTOWERENTHALPYRECOVERYLOOPS + + +thermosiphonsealedtubeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONSEALEDTUBEHEATEXCHANGERS + + +thermosiphoncoiltypeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONCOILTYPEHEATEXCHANGERS + + +userdefined = IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED + + +notdefined = IfcAirToAirHeatRecoveryTypeEnum.NOTDEFINED + + +IfcAlarmTypeEnum = enum_namespace() + + +bell = IfcAlarmTypeEnum.BELL + + +breakglassbutton = IfcAlarmTypeEnum.BREAKGLASSBUTTON + + +light = IfcAlarmTypeEnum.LIGHT + + +manualpullbox = IfcAlarmTypeEnum.MANUALPULLBOX + + +siren = IfcAlarmTypeEnum.SIREN + + +whistle = IfcAlarmTypeEnum.WHISTLE + + +userdefined = IfcAlarmTypeEnum.USERDEFINED + + +notdefined = IfcAlarmTypeEnum.NOTDEFINED + + +IfcAlignmentTypeEnum = enum_namespace() + + +userdefined = IfcAlignmentTypeEnum.USERDEFINED + + +notdefined = IfcAlignmentTypeEnum.NOTDEFINED + + +IfcAnalysisModelTypeEnum = enum_namespace() + + +in_plane_loading_2d = IfcAnalysisModelTypeEnum.IN_PLANE_LOADING_2D + + +out_plane_loading_2d = IfcAnalysisModelTypeEnum.OUT_PLANE_LOADING_2D + + +loading_3d = IfcAnalysisModelTypeEnum.LOADING_3D + + +userdefined = IfcAnalysisModelTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisModelTypeEnum.NOTDEFINED + + +IfcAnalysisTheoryTypeEnum = enum_namespace() + + +first_order_theory = IfcAnalysisTheoryTypeEnum.FIRST_ORDER_THEORY + + +second_order_theory = IfcAnalysisTheoryTypeEnum.SECOND_ORDER_THEORY + + +third_order_theory = IfcAnalysisTheoryTypeEnum.THIRD_ORDER_THEORY + + +full_nonlinear_theory = IfcAnalysisTheoryTypeEnum.FULL_NONLINEAR_THEORY + + +userdefined = IfcAnalysisTheoryTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisTheoryTypeEnum.NOTDEFINED + + +IfcArithmeticOperatorEnum = enum_namespace() + + +add = IfcArithmeticOperatorEnum.ADD + + +divide = IfcArithmeticOperatorEnum.DIVIDE + + +multiply = IfcArithmeticOperatorEnum.MULTIPLY + + +subtract = IfcArithmeticOperatorEnum.SUBTRACT + + +IfcAssemblyPlaceEnum = enum_namespace() + + +site = IfcAssemblyPlaceEnum.SITE + + +factory = IfcAssemblyPlaceEnum.FACTORY + + +notdefined = IfcAssemblyPlaceEnum.NOTDEFINED + + +IfcAudioVisualApplianceTypeEnum = enum_namespace() + + +amplifier = IfcAudioVisualApplianceTypeEnum.AMPLIFIER + + +camera = IfcAudioVisualApplianceTypeEnum.CAMERA + + +display = IfcAudioVisualApplianceTypeEnum.DISPLAY + + +microphone = IfcAudioVisualApplianceTypeEnum.MICROPHONE + + +player = IfcAudioVisualApplianceTypeEnum.PLAYER + + +projector = IfcAudioVisualApplianceTypeEnum.PROJECTOR + + +receiver = IfcAudioVisualApplianceTypeEnum.RECEIVER + + +speaker = IfcAudioVisualApplianceTypeEnum.SPEAKER + + +switcher = IfcAudioVisualApplianceTypeEnum.SWITCHER + + +telephone = IfcAudioVisualApplianceTypeEnum.TELEPHONE + + +tuner = IfcAudioVisualApplianceTypeEnum.TUNER + + +userdefined = IfcAudioVisualApplianceTypeEnum.USERDEFINED + + +notdefined = IfcAudioVisualApplianceTypeEnum.NOTDEFINED + + +IfcBSplineCurveForm = enum_namespace() + + +polyline_form = IfcBSplineCurveForm.POLYLINE_FORM + + +circular_arc = IfcBSplineCurveForm.CIRCULAR_ARC + + +elliptic_arc = IfcBSplineCurveForm.ELLIPTIC_ARC + + +parabolic_arc = IfcBSplineCurveForm.PARABOLIC_ARC + + +hyperbolic_arc = IfcBSplineCurveForm.HYPERBOLIC_ARC + + +unspecified = IfcBSplineCurveForm.UNSPECIFIED + + +IfcBSplineSurfaceForm = enum_namespace() + + +plane_surf = IfcBSplineSurfaceForm.PLANE_SURF + + +cylindrical_surf = IfcBSplineSurfaceForm.CYLINDRICAL_SURF + + +conical_surf = IfcBSplineSurfaceForm.CONICAL_SURF + + +spherical_surf = IfcBSplineSurfaceForm.SPHERICAL_SURF + + +toroidal_surf = IfcBSplineSurfaceForm.TOROIDAL_SURF + + +surf_of_revolution = IfcBSplineSurfaceForm.SURF_OF_REVOLUTION + + +ruled_surf = IfcBSplineSurfaceForm.RULED_SURF + + +generalised_cone = IfcBSplineSurfaceForm.GENERALISED_CONE + + +quadric_surf = IfcBSplineSurfaceForm.QUADRIC_SURF + + +surf_of_linear_extrusion = IfcBSplineSurfaceForm.SURF_OF_LINEAR_EXTRUSION + + +unspecified = IfcBSplineSurfaceForm.UNSPECIFIED + + +IfcBeamTypeEnum = enum_namespace() + + +beam = IfcBeamTypeEnum.BEAM + + +joist = IfcBeamTypeEnum.JOIST + + +hollowcore = IfcBeamTypeEnum.HOLLOWCORE + + +lintel = IfcBeamTypeEnum.LINTEL + + +spandrel = IfcBeamTypeEnum.SPANDREL + + +t_beam = IfcBeamTypeEnum.T_BEAM + + +girder_segment = IfcBeamTypeEnum.GIRDER_SEGMENT + + +diaphragm = IfcBeamTypeEnum.DIAPHRAGM + + +piercap = IfcBeamTypeEnum.PIERCAP + + +hatstone = IfcBeamTypeEnum.HATSTONE + + +cornice = IfcBeamTypeEnum.CORNICE + + +edgebeam = IfcBeamTypeEnum.EDGEBEAM + + +userdefined = IfcBeamTypeEnum.USERDEFINED + + +notdefined = IfcBeamTypeEnum.NOTDEFINED + + +IfcBearingTypeDisplacementEnum = enum_namespace() + + +fixed_movement = IfcBearingTypeDisplacementEnum.FIXED_MOVEMENT + + +guided_longitudinal = IfcBearingTypeDisplacementEnum.GUIDED_LONGITUDINAL + + +guided_transversal = IfcBearingTypeDisplacementEnum.GUIDED_TRANSVERSAL + + +free_movement = IfcBearingTypeDisplacementEnum.FREE_MOVEMENT + + +notdefined = IfcBearingTypeDisplacementEnum.NOTDEFINED + + +IfcBearingTypeEnum = enum_namespace() + + +cylindrical = IfcBearingTypeEnum.CYLINDRICAL + + +spherical = IfcBearingTypeEnum.SPHERICAL + + +elastomeric = IfcBearingTypeEnum.ELASTOMERIC + + +pot = IfcBearingTypeEnum.POT + + +guide = IfcBearingTypeEnum.GUIDE + + +rocker = IfcBearingTypeEnum.ROCKER + + +roller = IfcBearingTypeEnum.ROLLER + + +disk = IfcBearingTypeEnum.DISK + + +userdefined = IfcBearingTypeEnum.USERDEFINED + + +notdefined = IfcBearingTypeEnum.NOTDEFINED + + +IfcBenchmarkEnum = enum_namespace() + + +greaterthan = IfcBenchmarkEnum.GREATERTHAN + + +greaterthanorequalto = IfcBenchmarkEnum.GREATERTHANOREQUALTO + + +lessthan = IfcBenchmarkEnum.LESSTHAN + + +lessthanorequalto = IfcBenchmarkEnum.LESSTHANOREQUALTO + + +equalto = IfcBenchmarkEnum.EQUALTO + + +notequalto = IfcBenchmarkEnum.NOTEQUALTO + + +includes = IfcBenchmarkEnum.INCLUDES + + +notincludes = IfcBenchmarkEnum.NOTINCLUDES + + +includedin = IfcBenchmarkEnum.INCLUDEDIN + + +notincludedin = IfcBenchmarkEnum.NOTINCLUDEDIN + + +IfcBoilerTypeEnum = enum_namespace() + + +water = IfcBoilerTypeEnum.WATER + + +steam = IfcBoilerTypeEnum.STEAM + + +userdefined = IfcBoilerTypeEnum.USERDEFINED + + +notdefined = IfcBoilerTypeEnum.NOTDEFINED + + +IfcBooleanOperator = enum_namespace() + + +union = IfcBooleanOperator.UNION + + +intersection = IfcBooleanOperator.INTERSECTION + + +difference = IfcBooleanOperator.DIFFERENCE + + +IfcBridgePartTypeEnum = enum_namespace() + + +abutment = IfcBridgePartTypeEnum.ABUTMENT + + +deck = IfcBridgePartTypeEnum.DECK + + +deck_segment = IfcBridgePartTypeEnum.DECK_SEGMENT + + +foundation = IfcBridgePartTypeEnum.FOUNDATION + + +pier = IfcBridgePartTypeEnum.PIER + + +pier_segment = IfcBridgePartTypeEnum.PIER_SEGMENT + + +pylon = IfcBridgePartTypeEnum.PYLON + + +substructure = IfcBridgePartTypeEnum.SUBSTRUCTURE + + +superstructure = IfcBridgePartTypeEnum.SUPERSTRUCTURE + + +surfacestructure = IfcBridgePartTypeEnum.SURFACESTRUCTURE + + +userdefined = IfcBridgePartTypeEnum.USERDEFINED + + +notdefined = IfcBridgePartTypeEnum.NOTDEFINED + + +IfcBridgeTypeEnum = enum_namespace() + + +arched = IfcBridgeTypeEnum.ARCHED + + +cable_stayed = IfcBridgeTypeEnum.CABLE_STAYED + + +cantilever = IfcBridgeTypeEnum.CANTILEVER + + +culvert = IfcBridgeTypeEnum.CULVERT + + +framework = IfcBridgeTypeEnum.FRAMEWORK + + +girder = IfcBridgeTypeEnum.GIRDER + + +suspension = IfcBridgeTypeEnum.SUSPENSION + + +truss = IfcBridgeTypeEnum.TRUSS + + +userdefined = IfcBridgeTypeEnum.USERDEFINED + + +notdefined = IfcBridgeTypeEnum.NOTDEFINED + + +IfcBuildingElementPartTypeEnum = enum_namespace() + + +insulation = IfcBuildingElementPartTypeEnum.INSULATION + + +precastpanel = IfcBuildingElementPartTypeEnum.PRECASTPANEL + + +apron = IfcBuildingElementPartTypeEnum.APRON + + +userdefined = IfcBuildingElementPartTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementPartTypeEnum.NOTDEFINED + + +IfcBuildingElementProxyTypeEnum = enum_namespace() + + +complex = IfcBuildingElementProxyTypeEnum.COMPLEX + + +element = IfcBuildingElementProxyTypeEnum.ELEMENT + + +partial = IfcBuildingElementProxyTypeEnum.PARTIAL + + +provisionforvoid = IfcBuildingElementProxyTypeEnum.PROVISIONFORVOID + + +provisionforspace = IfcBuildingElementProxyTypeEnum.PROVISIONFORSPACE + + +userdefined = IfcBuildingElementProxyTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementProxyTypeEnum.NOTDEFINED + + +IfcBuildingSystemTypeEnum = enum_namespace() + + +fenestration = IfcBuildingSystemTypeEnum.FENESTRATION + + +foundation = IfcBuildingSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuildingSystemTypeEnum.LOADBEARING + + +outershell = IfcBuildingSystemTypeEnum.OUTERSHELL + + +shading = IfcBuildingSystemTypeEnum.SHADING + + +transport = IfcBuildingSystemTypeEnum.TRANSPORT + + +reinforcing = IfcBuildingSystemTypeEnum.REINFORCING + + +prestressing = IfcBuildingSystemTypeEnum.PRESTRESSING + + +userdefined = IfcBuildingSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuildingSystemTypeEnum.NOTDEFINED + + +IfcBurnerTypeEnum = enum_namespace() + + +userdefined = IfcBurnerTypeEnum.USERDEFINED + + +notdefined = IfcBurnerTypeEnum.NOTDEFINED + + +IfcCableCarrierFittingTypeEnum = enum_namespace() + + +bend = IfcCableCarrierFittingTypeEnum.BEND + + +cross = IfcCableCarrierFittingTypeEnum.CROSS + + +reducer = IfcCableCarrierFittingTypeEnum.REDUCER + + +tee = IfcCableCarrierFittingTypeEnum.TEE + + +userdefined = IfcCableCarrierFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierFittingTypeEnum.NOTDEFINED + + +IfcCableCarrierSegmentTypeEnum = enum_namespace() + + +cableladdersegment = IfcCableCarrierSegmentTypeEnum.CABLELADDERSEGMENT + + +cabletraysegment = IfcCableCarrierSegmentTypeEnum.CABLETRAYSEGMENT + + +cabletrunkingsegment = IfcCableCarrierSegmentTypeEnum.CABLETRUNKINGSEGMENT + + +conduitsegment = IfcCableCarrierSegmentTypeEnum.CONDUITSEGMENT + + +userdefined = IfcCableCarrierSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierSegmentTypeEnum.NOTDEFINED + + +IfcCableFittingTypeEnum = enum_namespace() + + +connector = IfcCableFittingTypeEnum.CONNECTOR + + +entry = IfcCableFittingTypeEnum.ENTRY + + +exit = IfcCableFittingTypeEnum.EXIT + + +junction = IfcCableFittingTypeEnum.JUNCTION + + +transition = IfcCableFittingTypeEnum.TRANSITION + + +userdefined = IfcCableFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableFittingTypeEnum.NOTDEFINED + + +IfcCableSegmentTypeEnum = enum_namespace() + + +busbarsegment = IfcCableSegmentTypeEnum.BUSBARSEGMENT + + +cablesegment = IfcCableSegmentTypeEnum.CABLESEGMENT + + +conductorsegment = IfcCableSegmentTypeEnum.CONDUCTORSEGMENT + + +coresegment = IfcCableSegmentTypeEnum.CORESEGMENT + + +userdefined = IfcCableSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableSegmentTypeEnum.NOTDEFINED + + +IfcCaissonFoundationTypeEnum = enum_namespace() + + +well = IfcCaissonFoundationTypeEnum.WELL + + +caisson = IfcCaissonFoundationTypeEnum.CAISSON + + +userdefined = IfcCaissonFoundationTypeEnum.USERDEFINED + + +notdefined = IfcCaissonFoundationTypeEnum.NOTDEFINED + + +IfcChangeActionEnum = enum_namespace() + + +nochange = IfcChangeActionEnum.NOCHANGE + + +modified = IfcChangeActionEnum.MODIFIED + + +added = IfcChangeActionEnum.ADDED + + +deleted = IfcChangeActionEnum.DELETED + + +notdefined = IfcChangeActionEnum.NOTDEFINED + + +IfcChillerTypeEnum = enum_namespace() + + +aircooled = IfcChillerTypeEnum.AIRCOOLED + + +watercooled = IfcChillerTypeEnum.WATERCOOLED + + +heatrecovery = IfcChillerTypeEnum.HEATRECOVERY + + +userdefined = IfcChillerTypeEnum.USERDEFINED + + +notdefined = IfcChillerTypeEnum.NOTDEFINED + + +IfcChimneyTypeEnum = enum_namespace() + + +userdefined = IfcChimneyTypeEnum.USERDEFINED + + +notdefined = IfcChimneyTypeEnum.NOTDEFINED + + +IfcCoilTypeEnum = enum_namespace() + + +dxcoolingcoil = IfcCoilTypeEnum.DXCOOLINGCOIL + + +electricheatingcoil = IfcCoilTypeEnum.ELECTRICHEATINGCOIL + + +gasheatingcoil = IfcCoilTypeEnum.GASHEATINGCOIL + + +hydroniccoil = IfcCoilTypeEnum.HYDRONICCOIL + + +steamheatingcoil = IfcCoilTypeEnum.STEAMHEATINGCOIL + + +watercoolingcoil = IfcCoilTypeEnum.WATERCOOLINGCOIL + + +waterheatingcoil = IfcCoilTypeEnum.WATERHEATINGCOIL + + +userdefined = IfcCoilTypeEnum.USERDEFINED + + +notdefined = IfcCoilTypeEnum.NOTDEFINED + + +IfcColumnTypeEnum = enum_namespace() + + +column = IfcColumnTypeEnum.COLUMN + + +pilaster = IfcColumnTypeEnum.PILASTER + + +pierstem = IfcColumnTypeEnum.PIERSTEM + + +pierstem_segment = IfcColumnTypeEnum.PIERSTEM_SEGMENT + + +standcolumn = IfcColumnTypeEnum.STANDCOLUMN + + +userdefined = IfcColumnTypeEnum.USERDEFINED + + +notdefined = IfcColumnTypeEnum.NOTDEFINED + + +IfcCommunicationsApplianceTypeEnum = enum_namespace() + + +antenna = IfcCommunicationsApplianceTypeEnum.ANTENNA + + +computer = IfcCommunicationsApplianceTypeEnum.COMPUTER + + +fax = IfcCommunicationsApplianceTypeEnum.FAX + + +gateway = IfcCommunicationsApplianceTypeEnum.GATEWAY + + +modem = IfcCommunicationsApplianceTypeEnum.MODEM + + +networkappliance = IfcCommunicationsApplianceTypeEnum.NETWORKAPPLIANCE + + +networkbridge = IfcCommunicationsApplianceTypeEnum.NETWORKBRIDGE + + +networkhub = IfcCommunicationsApplianceTypeEnum.NETWORKHUB + + +printer = IfcCommunicationsApplianceTypeEnum.PRINTER + + +repeater = IfcCommunicationsApplianceTypeEnum.REPEATER + + +router = IfcCommunicationsApplianceTypeEnum.ROUTER + + +scanner = IfcCommunicationsApplianceTypeEnum.SCANNER + + +userdefined = IfcCommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcCommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcComplexPropertyTemplateTypeEnum = enum_namespace() + + +p_complex = IfcComplexPropertyTemplateTypeEnum.P_COMPLEX + + +q_complex = IfcComplexPropertyTemplateTypeEnum.Q_COMPLEX + + +IfcCompressorTypeEnum = enum_namespace() + + +dynamic = IfcCompressorTypeEnum.DYNAMIC + + +reciprocating = IfcCompressorTypeEnum.RECIPROCATING + + +rotary = IfcCompressorTypeEnum.ROTARY + + +scroll = IfcCompressorTypeEnum.SCROLL + + +trochoidal = IfcCompressorTypeEnum.TROCHOIDAL + + +singlestage = IfcCompressorTypeEnum.SINGLESTAGE + + +booster = IfcCompressorTypeEnum.BOOSTER + + +opentype = IfcCompressorTypeEnum.OPENTYPE + + +hermetic = IfcCompressorTypeEnum.HERMETIC + + +semihermetic = IfcCompressorTypeEnum.SEMIHERMETIC + + +weldedshellhermetic = IfcCompressorTypeEnum.WELDEDSHELLHERMETIC + + +rollingpiston = IfcCompressorTypeEnum.ROLLINGPISTON + + +rotaryvane = IfcCompressorTypeEnum.ROTARYVANE + + +singlescrew = IfcCompressorTypeEnum.SINGLESCREW + + +twinscrew = IfcCompressorTypeEnum.TWINSCREW + + +userdefined = IfcCompressorTypeEnum.USERDEFINED + + +notdefined = IfcCompressorTypeEnum.NOTDEFINED + + +IfcCondenserTypeEnum = enum_namespace() + + +aircooled = IfcCondenserTypeEnum.AIRCOOLED + + +evaporativecooled = IfcCondenserTypeEnum.EVAPORATIVECOOLED + + +watercooled = IfcCondenserTypeEnum.WATERCOOLED + + +watercooledbrazedplate = IfcCondenserTypeEnum.WATERCOOLEDBRAZEDPLATE + + +watercooledshellcoil = IfcCondenserTypeEnum.WATERCOOLEDSHELLCOIL + + +watercooledshelltube = IfcCondenserTypeEnum.WATERCOOLEDSHELLTUBE + + +watercooledtubeintube = IfcCondenserTypeEnum.WATERCOOLEDTUBEINTUBE + + +userdefined = IfcCondenserTypeEnum.USERDEFINED + + +notdefined = IfcCondenserTypeEnum.NOTDEFINED + + +IfcConnectionTypeEnum = enum_namespace() + + +atpath = IfcConnectionTypeEnum.ATPATH + + +atstart = IfcConnectionTypeEnum.ATSTART + + +atend = IfcConnectionTypeEnum.ATEND + + +notdefined = IfcConnectionTypeEnum.NOTDEFINED + + +IfcConstraintEnum = enum_namespace() + + +hard = IfcConstraintEnum.HARD + + +soft = IfcConstraintEnum.SOFT + + +advisory = IfcConstraintEnum.ADVISORY + + +userdefined = IfcConstraintEnum.USERDEFINED + + +notdefined = IfcConstraintEnum.NOTDEFINED + + +IfcConstructionEquipmentResourceTypeEnum = enum_namespace() + + +demolishing = IfcConstructionEquipmentResourceTypeEnum.DEMOLISHING + + +earthmoving = IfcConstructionEquipmentResourceTypeEnum.EARTHMOVING + + +erecting = IfcConstructionEquipmentResourceTypeEnum.ERECTING + + +heating = IfcConstructionEquipmentResourceTypeEnum.HEATING + + +lighting = IfcConstructionEquipmentResourceTypeEnum.LIGHTING + + +paving = IfcConstructionEquipmentResourceTypeEnum.PAVING + + +pumping = IfcConstructionEquipmentResourceTypeEnum.PUMPING + + +transporting = IfcConstructionEquipmentResourceTypeEnum.TRANSPORTING + + +userdefined = IfcConstructionEquipmentResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionEquipmentResourceTypeEnum.NOTDEFINED + + +IfcConstructionMaterialResourceTypeEnum = enum_namespace() + + +aggregates = IfcConstructionMaterialResourceTypeEnum.AGGREGATES + + +concrete = IfcConstructionMaterialResourceTypeEnum.CONCRETE + + +drywall = IfcConstructionMaterialResourceTypeEnum.DRYWALL + + +fuel = IfcConstructionMaterialResourceTypeEnum.FUEL + + +gypsum = IfcConstructionMaterialResourceTypeEnum.GYPSUM + + +masonry = IfcConstructionMaterialResourceTypeEnum.MASONRY + + +metal = IfcConstructionMaterialResourceTypeEnum.METAL + + +plastic = IfcConstructionMaterialResourceTypeEnum.PLASTIC + + +wood = IfcConstructionMaterialResourceTypeEnum.WOOD + + +notdefined = IfcConstructionMaterialResourceTypeEnum.NOTDEFINED + + +userdefined = IfcConstructionMaterialResourceTypeEnum.USERDEFINED + + +IfcConstructionProductResourceTypeEnum = enum_namespace() + + +assembly = IfcConstructionProductResourceTypeEnum.ASSEMBLY + + +formwork = IfcConstructionProductResourceTypeEnum.FORMWORK + + +userdefined = IfcConstructionProductResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionProductResourceTypeEnum.NOTDEFINED + + +IfcControllerTypeEnum = enum_namespace() + + +floating = IfcControllerTypeEnum.FLOATING + + +programmable = IfcControllerTypeEnum.PROGRAMMABLE + + +proportional = IfcControllerTypeEnum.PROPORTIONAL + + +multiposition = IfcControllerTypeEnum.MULTIPOSITION + + +twoposition = IfcControllerTypeEnum.TWOPOSITION + + +userdefined = IfcControllerTypeEnum.USERDEFINED + + +notdefined = IfcControllerTypeEnum.NOTDEFINED + + +IfcCooledBeamTypeEnum = enum_namespace() + + +active = IfcCooledBeamTypeEnum.ACTIVE + + +passive = IfcCooledBeamTypeEnum.PASSIVE + + +userdefined = IfcCooledBeamTypeEnum.USERDEFINED + + +notdefined = IfcCooledBeamTypeEnum.NOTDEFINED + + +IfcCoolingTowerTypeEnum = enum_namespace() + + +naturaldraft = IfcCoolingTowerTypeEnum.NATURALDRAFT + + +mechanicalinduceddraft = IfcCoolingTowerTypeEnum.MECHANICALINDUCEDDRAFT + + +mechanicalforceddraft = IfcCoolingTowerTypeEnum.MECHANICALFORCEDDRAFT + + +userdefined = IfcCoolingTowerTypeEnum.USERDEFINED + + +notdefined = IfcCoolingTowerTypeEnum.NOTDEFINED + + +IfcCostItemTypeEnum = enum_namespace() + + +userdefined = IfcCostItemTypeEnum.USERDEFINED + + +notdefined = IfcCostItemTypeEnum.NOTDEFINED + + +IfcCostScheduleTypeEnum = enum_namespace() + + +budget = IfcCostScheduleTypeEnum.BUDGET + + +costplan = IfcCostScheduleTypeEnum.COSTPLAN + + +estimate = IfcCostScheduleTypeEnum.ESTIMATE + + +tender = IfcCostScheduleTypeEnum.TENDER + + +pricedbillofquantities = IfcCostScheduleTypeEnum.PRICEDBILLOFQUANTITIES + + +unpricedbillofquantities = IfcCostScheduleTypeEnum.UNPRICEDBILLOFQUANTITIES + + +scheduleofrates = IfcCostScheduleTypeEnum.SCHEDULEOFRATES + + +userdefined = IfcCostScheduleTypeEnum.USERDEFINED + + +notdefined = IfcCostScheduleTypeEnum.NOTDEFINED + + +IfcCoveringTypeEnum = enum_namespace() + + +ceiling = IfcCoveringTypeEnum.CEILING + + +flooring = IfcCoveringTypeEnum.FLOORING + + +cladding = IfcCoveringTypeEnum.CLADDING + + +roofing = IfcCoveringTypeEnum.ROOFING + + +molding = IfcCoveringTypeEnum.MOLDING + + +skirtingboard = IfcCoveringTypeEnum.SKIRTINGBOARD + + +insulation = IfcCoveringTypeEnum.INSULATION + + +membrane = IfcCoveringTypeEnum.MEMBRANE + + +sleeving = IfcCoveringTypeEnum.SLEEVING + + +wrapping = IfcCoveringTypeEnum.WRAPPING + + +coping = IfcCoveringTypeEnum.COPING + + +userdefined = IfcCoveringTypeEnum.USERDEFINED + + +notdefined = IfcCoveringTypeEnum.NOTDEFINED + + +IfcCrewResourceTypeEnum = enum_namespace() + + +office = IfcCrewResourceTypeEnum.OFFICE + + +site = IfcCrewResourceTypeEnum.SITE + + +userdefined = IfcCrewResourceTypeEnum.USERDEFINED + + +notdefined = IfcCrewResourceTypeEnum.NOTDEFINED + + +IfcCurtainWallTypeEnum = enum_namespace() + + +userdefined = IfcCurtainWallTypeEnum.USERDEFINED + + +notdefined = IfcCurtainWallTypeEnum.NOTDEFINED + + +IfcCurveInterpolationEnum = enum_namespace() + + +linear = IfcCurveInterpolationEnum.LINEAR + + +log_linear = IfcCurveInterpolationEnum.LOG_LINEAR + + +log_log = IfcCurveInterpolationEnum.LOG_LOG + + +notdefined = IfcCurveInterpolationEnum.NOTDEFINED + + +IfcDamperTypeEnum = enum_namespace() + + +backdraftdamper = IfcDamperTypeEnum.BACKDRAFTDAMPER + + +balancingdamper = IfcDamperTypeEnum.BALANCINGDAMPER + + +blastdamper = IfcDamperTypeEnum.BLASTDAMPER + + +controldamper = IfcDamperTypeEnum.CONTROLDAMPER + + +firedamper = IfcDamperTypeEnum.FIREDAMPER + + +firesmokedamper = IfcDamperTypeEnum.FIRESMOKEDAMPER + + +fumehoodexhaust = IfcDamperTypeEnum.FUMEHOODEXHAUST + + +gravitydamper = IfcDamperTypeEnum.GRAVITYDAMPER + + +gravityreliefdamper = IfcDamperTypeEnum.GRAVITYRELIEFDAMPER + + +reliefdamper = IfcDamperTypeEnum.RELIEFDAMPER + + +smokedamper = IfcDamperTypeEnum.SMOKEDAMPER + + +userdefined = IfcDamperTypeEnum.USERDEFINED + + +notdefined = IfcDamperTypeEnum.NOTDEFINED + + +IfcDataOriginEnum = enum_namespace() + + +measured = IfcDataOriginEnum.MEASURED + + +predicted = IfcDataOriginEnum.PREDICTED + + +simulated = IfcDataOriginEnum.SIMULATED + + +userdefined = IfcDataOriginEnum.USERDEFINED + + +notdefined = IfcDataOriginEnum.NOTDEFINED + + +IfcDerivedUnitEnum = enum_namespace() + + +angularvelocityunit = IfcDerivedUnitEnum.ANGULARVELOCITYUNIT + + +areadensityunit = IfcDerivedUnitEnum.AREADENSITYUNIT + + +compoundplaneangleunit = IfcDerivedUnitEnum.COMPOUNDPLANEANGLEUNIT + + +dynamicviscosityunit = IfcDerivedUnitEnum.DYNAMICVISCOSITYUNIT + + +heatfluxdensityunit = IfcDerivedUnitEnum.HEATFLUXDENSITYUNIT + + +integercountrateunit = IfcDerivedUnitEnum.INTEGERCOUNTRATEUNIT + + +isothermalmoisturecapacityunit = IfcDerivedUnitEnum.ISOTHERMALMOISTURECAPACITYUNIT + + +kinematicviscosityunit = IfcDerivedUnitEnum.KINEMATICVISCOSITYUNIT + + +linearvelocityunit = IfcDerivedUnitEnum.LINEARVELOCITYUNIT + + +massdensityunit = IfcDerivedUnitEnum.MASSDENSITYUNIT + + +massflowrateunit = IfcDerivedUnitEnum.MASSFLOWRATEUNIT + + +moisturediffusivityunit = IfcDerivedUnitEnum.MOISTUREDIFFUSIVITYUNIT + + +molecularweightunit = IfcDerivedUnitEnum.MOLECULARWEIGHTUNIT + + +specificheatcapacityunit = IfcDerivedUnitEnum.SPECIFICHEATCAPACITYUNIT + + +thermaladmittanceunit = IfcDerivedUnitEnum.THERMALADMITTANCEUNIT + + +thermalconductanceunit = IfcDerivedUnitEnum.THERMALCONDUCTANCEUNIT + + +thermalresistanceunit = IfcDerivedUnitEnum.THERMALRESISTANCEUNIT + + +thermaltransmittanceunit = IfcDerivedUnitEnum.THERMALTRANSMITTANCEUNIT + + +vaporpermeabilityunit = IfcDerivedUnitEnum.VAPORPERMEABILITYUNIT + + +volumetricflowrateunit = IfcDerivedUnitEnum.VOLUMETRICFLOWRATEUNIT + + +rotationalfrequencyunit = IfcDerivedUnitEnum.ROTATIONALFREQUENCYUNIT + + +torqueunit = IfcDerivedUnitEnum.TORQUEUNIT + + +momentofinertiaunit = IfcDerivedUnitEnum.MOMENTOFINERTIAUNIT + + +linearmomentunit = IfcDerivedUnitEnum.LINEARMOMENTUNIT + + +linearforceunit = IfcDerivedUnitEnum.LINEARFORCEUNIT + + +planarforceunit = IfcDerivedUnitEnum.PLANARFORCEUNIT + + +modulusofelasticityunit = IfcDerivedUnitEnum.MODULUSOFELASTICITYUNIT + + +shearmodulusunit = IfcDerivedUnitEnum.SHEARMODULUSUNIT + + +linearstiffnessunit = IfcDerivedUnitEnum.LINEARSTIFFNESSUNIT + + +rotationalstiffnessunit = IfcDerivedUnitEnum.ROTATIONALSTIFFNESSUNIT + + +modulusofsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFSUBGRADEREACTIONUNIT + + +accelerationunit = IfcDerivedUnitEnum.ACCELERATIONUNIT + + +curvatureunit = IfcDerivedUnitEnum.CURVATUREUNIT + + +heatingvalueunit = IfcDerivedUnitEnum.HEATINGVALUEUNIT + + +ionconcentrationunit = IfcDerivedUnitEnum.IONCONCENTRATIONUNIT + + +luminousintensitydistributionunit = IfcDerivedUnitEnum.LUMINOUSINTENSITYDISTRIBUTIONUNIT + + +massperlengthunit = IfcDerivedUnitEnum.MASSPERLENGTHUNIT + + +modulusoflinearsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFLINEARSUBGRADEREACTIONUNIT + + +modulusofrotationalsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFROTATIONALSUBGRADEREACTIONUNIT + + +phunit = IfcDerivedUnitEnum.PHUNIT + + +rotationalmassunit = IfcDerivedUnitEnum.ROTATIONALMASSUNIT + + +sectionareaintegralunit = IfcDerivedUnitEnum.SECTIONAREAINTEGRALUNIT + + +sectionmodulusunit = IfcDerivedUnitEnum.SECTIONMODULUSUNIT + + +soundpowerlevelunit = IfcDerivedUnitEnum.SOUNDPOWERLEVELUNIT + + +soundpowerunit = IfcDerivedUnitEnum.SOUNDPOWERUNIT + + +soundpressurelevelunit = IfcDerivedUnitEnum.SOUNDPRESSURELEVELUNIT + + +soundpressureunit = IfcDerivedUnitEnum.SOUNDPRESSUREUNIT + + +temperaturegradientunit = IfcDerivedUnitEnum.TEMPERATUREGRADIENTUNIT + + +temperaturerateofchangeunit = IfcDerivedUnitEnum.TEMPERATURERATEOFCHANGEUNIT + + +thermalexpansioncoefficientunit = IfcDerivedUnitEnum.THERMALEXPANSIONCOEFFICIENTUNIT + + +warpingconstantunit = IfcDerivedUnitEnum.WARPINGCONSTANTUNIT + + +warpingmomentunit = IfcDerivedUnitEnum.WARPINGMOMENTUNIT + + +userdefined = IfcDerivedUnitEnum.USERDEFINED + + +IfcDirectionSenseEnum = enum_namespace() + + +positive = IfcDirectionSenseEnum.POSITIVE + + +negative = IfcDirectionSenseEnum.NEGATIVE + + +IfcDiscreteAccessoryTypeEnum = enum_namespace() + + +anchorplate = IfcDiscreteAccessoryTypeEnum.ANCHORPLATE + + +bracket = IfcDiscreteAccessoryTypeEnum.BRACKET + + +shoe = IfcDiscreteAccessoryTypeEnum.SHOE + + +expansion_joint_device = IfcDiscreteAccessoryTypeEnum.EXPANSION_JOINT_DEVICE + + +userdefined = IfcDiscreteAccessoryTypeEnum.USERDEFINED + + +notdefined = IfcDiscreteAccessoryTypeEnum.NOTDEFINED + + +IfcDistributionChamberElementTypeEnum = enum_namespace() + + +formedduct = IfcDistributionChamberElementTypeEnum.FORMEDDUCT + + +inspectionchamber = IfcDistributionChamberElementTypeEnum.INSPECTIONCHAMBER + + +inspectionpit = IfcDistributionChamberElementTypeEnum.INSPECTIONPIT + + +manhole = IfcDistributionChamberElementTypeEnum.MANHOLE + + +meterchamber = IfcDistributionChamberElementTypeEnum.METERCHAMBER + + +sump = IfcDistributionChamberElementTypeEnum.SUMP + + +trench = IfcDistributionChamberElementTypeEnum.TRENCH + + +valvechamber = IfcDistributionChamberElementTypeEnum.VALVECHAMBER + + +userdefined = IfcDistributionChamberElementTypeEnum.USERDEFINED + + +notdefined = IfcDistributionChamberElementTypeEnum.NOTDEFINED + + +IfcDistributionPortTypeEnum = enum_namespace() + + +cable = IfcDistributionPortTypeEnum.CABLE + + +cablecarrier = IfcDistributionPortTypeEnum.CABLECARRIER + + +duct = IfcDistributionPortTypeEnum.DUCT + + +pipe = IfcDistributionPortTypeEnum.PIPE + + +userdefined = IfcDistributionPortTypeEnum.USERDEFINED + + +notdefined = IfcDistributionPortTypeEnum.NOTDEFINED + + +IfcDistributionSystemEnum = enum_namespace() + + +airconditioning = IfcDistributionSystemEnum.AIRCONDITIONING + + +audiovisual = IfcDistributionSystemEnum.AUDIOVISUAL + + +chemical = IfcDistributionSystemEnum.CHEMICAL + + +chilledwater = IfcDistributionSystemEnum.CHILLEDWATER + + +communication = IfcDistributionSystemEnum.COMMUNICATION + + +compressedair = IfcDistributionSystemEnum.COMPRESSEDAIR + + +condenserwater = IfcDistributionSystemEnum.CONDENSERWATER + + +control = IfcDistributionSystemEnum.CONTROL + + +conveying = IfcDistributionSystemEnum.CONVEYING + + +data = IfcDistributionSystemEnum.DATA + + +disposal = IfcDistributionSystemEnum.DISPOSAL + + +domesticcoldwater = IfcDistributionSystemEnum.DOMESTICCOLDWATER + + +domestichotwater = IfcDistributionSystemEnum.DOMESTICHOTWATER + + +drainage = IfcDistributionSystemEnum.DRAINAGE + + +earthing = IfcDistributionSystemEnum.EARTHING + + +electrical = IfcDistributionSystemEnum.ELECTRICAL + + +electroacoustic = IfcDistributionSystemEnum.ELECTROACOUSTIC + + +exhaust = IfcDistributionSystemEnum.EXHAUST + + +fireprotection = IfcDistributionSystemEnum.FIREPROTECTION + + +fuel = IfcDistributionSystemEnum.FUEL + + +gas = IfcDistributionSystemEnum.GAS + + +hazardous = IfcDistributionSystemEnum.HAZARDOUS + + +heating = IfcDistributionSystemEnum.HEATING + + +lighting = IfcDistributionSystemEnum.LIGHTING + + +lightningprotection = IfcDistributionSystemEnum.LIGHTNINGPROTECTION + + +municipalsolidwaste = IfcDistributionSystemEnum.MUNICIPALSOLIDWASTE + + +oil = IfcDistributionSystemEnum.OIL + + +operational = IfcDistributionSystemEnum.OPERATIONAL + + +powergeneration = IfcDistributionSystemEnum.POWERGENERATION + + +rainwater = IfcDistributionSystemEnum.RAINWATER + + +refrigeration = IfcDistributionSystemEnum.REFRIGERATION + + +security = IfcDistributionSystemEnum.SECURITY + + +sewage = IfcDistributionSystemEnum.SEWAGE + + +signal = IfcDistributionSystemEnum.SIGNAL + + +stormwater = IfcDistributionSystemEnum.STORMWATER + + +telephone = IfcDistributionSystemEnum.TELEPHONE + + +tv = IfcDistributionSystemEnum.TV + + +vacuum = IfcDistributionSystemEnum.VACUUM + + +vent = IfcDistributionSystemEnum.VENT + + +ventilation = IfcDistributionSystemEnum.VENTILATION + + +wastewater = IfcDistributionSystemEnum.WASTEWATER + + +watersupply = IfcDistributionSystemEnum.WATERSUPPLY + + +userdefined = IfcDistributionSystemEnum.USERDEFINED + + +notdefined = IfcDistributionSystemEnum.NOTDEFINED + + +IfcDocumentConfidentialityEnum = enum_namespace() + + +public = IfcDocumentConfidentialityEnum.PUBLIC + + +restricted = IfcDocumentConfidentialityEnum.RESTRICTED + + +confidential = IfcDocumentConfidentialityEnum.CONFIDENTIAL + + +personal = IfcDocumentConfidentialityEnum.PERSONAL + + +userdefined = IfcDocumentConfidentialityEnum.USERDEFINED + + +notdefined = IfcDocumentConfidentialityEnum.NOTDEFINED + + +IfcDocumentStatusEnum = enum_namespace() + + +draft = IfcDocumentStatusEnum.DRAFT + + +finaldraft = IfcDocumentStatusEnum.FINALDRAFT + + +final = IfcDocumentStatusEnum.FINAL + + +revision = IfcDocumentStatusEnum.REVISION + + +notdefined = IfcDocumentStatusEnum.NOTDEFINED + + +IfcDoorPanelOperationEnum = enum_namespace() + + +swinging = IfcDoorPanelOperationEnum.SWINGING + + +double_acting = IfcDoorPanelOperationEnum.DOUBLE_ACTING + + +sliding = IfcDoorPanelOperationEnum.SLIDING + + +folding = IfcDoorPanelOperationEnum.FOLDING + + +revolving = IfcDoorPanelOperationEnum.REVOLVING + + +rollingup = IfcDoorPanelOperationEnum.ROLLINGUP + + +fixedpanel = IfcDoorPanelOperationEnum.FIXEDPANEL + + +userdefined = IfcDoorPanelOperationEnum.USERDEFINED + + +notdefined = IfcDoorPanelOperationEnum.NOTDEFINED + + +IfcDoorPanelPositionEnum = enum_namespace() + + +left = IfcDoorPanelPositionEnum.LEFT + + +middle = IfcDoorPanelPositionEnum.MIDDLE + + +right = IfcDoorPanelPositionEnum.RIGHT + + +notdefined = IfcDoorPanelPositionEnum.NOTDEFINED + + +IfcDoorStyleConstructionEnum = enum_namespace() + + +aluminium = IfcDoorStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcDoorStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcDoorStyleConstructionEnum.STEEL + + +wood = IfcDoorStyleConstructionEnum.WOOD + + +aluminium_wood = IfcDoorStyleConstructionEnum.ALUMINIUM_WOOD + + +aluminium_plastic = IfcDoorStyleConstructionEnum.ALUMINIUM_PLASTIC + + +plastic = IfcDoorStyleConstructionEnum.PLASTIC + + +userdefined = IfcDoorStyleConstructionEnum.USERDEFINED + + +notdefined = IfcDoorStyleConstructionEnum.NOTDEFINED + + +IfcDoorStyleOperationEnum = enum_namespace() + + +single_swing_left = IfcDoorStyleOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorStyleOperationEnum.SINGLE_SWING_RIGHT + + +double_door_single_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_swing_left = IfcDoorStyleOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorStyleOperationEnum.DOUBLE_SWING_RIGHT + + +double_door_double_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +sliding_to_left = IfcDoorStyleOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorStyleOperationEnum.SLIDING_TO_RIGHT + + +double_door_sliding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SLIDING + + +folding_to_left = IfcDoorStyleOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorStyleOperationEnum.FOLDING_TO_RIGHT + + +double_door_folding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_FOLDING + + +revolving = IfcDoorStyleOperationEnum.REVOLVING + + +rollingup = IfcDoorStyleOperationEnum.ROLLINGUP + + +userdefined = IfcDoorStyleOperationEnum.USERDEFINED + + +notdefined = IfcDoorStyleOperationEnum.NOTDEFINED + + +IfcDoorTypeEnum = enum_namespace() + + +door = IfcDoorTypeEnum.DOOR + + +gate = IfcDoorTypeEnum.GATE + + +trapdoor = IfcDoorTypeEnum.TRAPDOOR + + +userdefined = IfcDoorTypeEnum.USERDEFINED + + +notdefined = IfcDoorTypeEnum.NOTDEFINED + + +IfcDoorTypeOperationEnum = enum_namespace() + + +single_swing_left = IfcDoorTypeOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorTypeOperationEnum.SINGLE_SWING_RIGHT + + +double_door_single_swing = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_swing_left = IfcDoorTypeOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorTypeOperationEnum.DOUBLE_SWING_RIGHT + + +double_door_double_swing = IfcDoorTypeOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +sliding_to_left = IfcDoorTypeOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorTypeOperationEnum.SLIDING_TO_RIGHT + + +double_door_sliding = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SLIDING + + +folding_to_left = IfcDoorTypeOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorTypeOperationEnum.FOLDING_TO_RIGHT + + +double_door_folding = IfcDoorTypeOperationEnum.DOUBLE_DOOR_FOLDING + + +revolving = IfcDoorTypeOperationEnum.REVOLVING + + +rollingup = IfcDoorTypeOperationEnum.ROLLINGUP + + +swing_fixed_left = IfcDoorTypeOperationEnum.SWING_FIXED_LEFT + + +swing_fixed_right = IfcDoorTypeOperationEnum.SWING_FIXED_RIGHT + + +userdefined = IfcDoorTypeOperationEnum.USERDEFINED + + +notdefined = IfcDoorTypeOperationEnum.NOTDEFINED + + +IfcDuctFittingTypeEnum = enum_namespace() + + +bend = IfcDuctFittingTypeEnum.BEND + + +connector = IfcDuctFittingTypeEnum.CONNECTOR + + +entry = IfcDuctFittingTypeEnum.ENTRY + + +exit = IfcDuctFittingTypeEnum.EXIT + + +junction = IfcDuctFittingTypeEnum.JUNCTION + + +obstruction = IfcDuctFittingTypeEnum.OBSTRUCTION + + +transition = IfcDuctFittingTypeEnum.TRANSITION + + +userdefined = IfcDuctFittingTypeEnum.USERDEFINED + + +notdefined = IfcDuctFittingTypeEnum.NOTDEFINED + + +IfcDuctSegmentTypeEnum = enum_namespace() + + +rigidsegment = IfcDuctSegmentTypeEnum.RIGIDSEGMENT + + +flexiblesegment = IfcDuctSegmentTypeEnum.FLEXIBLESEGMENT + + +userdefined = IfcDuctSegmentTypeEnum.USERDEFINED + + +notdefined = IfcDuctSegmentTypeEnum.NOTDEFINED + + +IfcDuctSilencerTypeEnum = enum_namespace() + + +flatoval = IfcDuctSilencerTypeEnum.FLATOVAL + + +rectangular = IfcDuctSilencerTypeEnum.RECTANGULAR + + +round = IfcDuctSilencerTypeEnum.ROUND + + +userdefined = IfcDuctSilencerTypeEnum.USERDEFINED + + +notdefined = IfcDuctSilencerTypeEnum.NOTDEFINED + + +IfcElectricApplianceTypeEnum = enum_namespace() + + +dishwasher = IfcElectricApplianceTypeEnum.DISHWASHER + + +electriccooker = IfcElectricApplianceTypeEnum.ELECTRICCOOKER + + +freestandingelectricheater = IfcElectricApplianceTypeEnum.FREESTANDINGELECTRICHEATER + + +freestandingfan = IfcElectricApplianceTypeEnum.FREESTANDINGFAN + + +freestandingwaterheater = IfcElectricApplianceTypeEnum.FREESTANDINGWATERHEATER + + +freestandingwatercooler = IfcElectricApplianceTypeEnum.FREESTANDINGWATERCOOLER + + +freezer = IfcElectricApplianceTypeEnum.FREEZER + + +fridge_freezer = IfcElectricApplianceTypeEnum.FRIDGE_FREEZER + + +handdryer = IfcElectricApplianceTypeEnum.HANDDRYER + + +kitchenmachine = IfcElectricApplianceTypeEnum.KITCHENMACHINE + + +microwave = IfcElectricApplianceTypeEnum.MICROWAVE + + +photocopier = IfcElectricApplianceTypeEnum.PHOTOCOPIER + + +refrigerator = IfcElectricApplianceTypeEnum.REFRIGERATOR + + +tumbledryer = IfcElectricApplianceTypeEnum.TUMBLEDRYER + + +vendingmachine = IfcElectricApplianceTypeEnum.VENDINGMACHINE + + +washingmachine = IfcElectricApplianceTypeEnum.WASHINGMACHINE + + +userdefined = IfcElectricApplianceTypeEnum.USERDEFINED + + +notdefined = IfcElectricApplianceTypeEnum.NOTDEFINED + + +IfcElectricDistributionBoardTypeEnum = enum_namespace() + + +consumerunit = IfcElectricDistributionBoardTypeEnum.CONSUMERUNIT + + +distributionboard = IfcElectricDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +motorcontrolcentre = IfcElectricDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +switchboard = IfcElectricDistributionBoardTypeEnum.SWITCHBOARD + + +userdefined = IfcElectricDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcElectricDistributionBoardTypeEnum.NOTDEFINED + + +IfcElectricFlowStorageDeviceTypeEnum = enum_namespace() + + +battery = IfcElectricFlowStorageDeviceTypeEnum.BATTERY + + +capacitorbank = IfcElectricFlowStorageDeviceTypeEnum.CAPACITORBANK + + +harmonicfilter = IfcElectricFlowStorageDeviceTypeEnum.HARMONICFILTER + + +inductorbank = IfcElectricFlowStorageDeviceTypeEnum.INDUCTORBANK + + +ups = IfcElectricFlowStorageDeviceTypeEnum.UPS + + +userdefined = IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowStorageDeviceTypeEnum.NOTDEFINED + + +IfcElectricGeneratorTypeEnum = enum_namespace() + + +chp = IfcElectricGeneratorTypeEnum.CHP + + +enginegenerator = IfcElectricGeneratorTypeEnum.ENGINEGENERATOR + + +standalone = IfcElectricGeneratorTypeEnum.STANDALONE + + +userdefined = IfcElectricGeneratorTypeEnum.USERDEFINED + + +notdefined = IfcElectricGeneratorTypeEnum.NOTDEFINED + + +IfcElectricMotorTypeEnum = enum_namespace() + + +dc = IfcElectricMotorTypeEnum.DC + + +induction = IfcElectricMotorTypeEnum.INDUCTION + + +polyphase = IfcElectricMotorTypeEnum.POLYPHASE + + +reluctancesynchronous = IfcElectricMotorTypeEnum.RELUCTANCESYNCHRONOUS + + +synchronous = IfcElectricMotorTypeEnum.SYNCHRONOUS + + +userdefined = IfcElectricMotorTypeEnum.USERDEFINED + + +notdefined = IfcElectricMotorTypeEnum.NOTDEFINED + + +IfcElectricTimeControlTypeEnum = enum_namespace() + + +timeclock = IfcElectricTimeControlTypeEnum.TIMECLOCK + + +timedelay = IfcElectricTimeControlTypeEnum.TIMEDELAY + + +relay = IfcElectricTimeControlTypeEnum.RELAY + + +userdefined = IfcElectricTimeControlTypeEnum.USERDEFINED + + +notdefined = IfcElectricTimeControlTypeEnum.NOTDEFINED + + +IfcElementAssemblyTypeEnum = enum_namespace() + + +accessory_assembly = IfcElementAssemblyTypeEnum.ACCESSORY_ASSEMBLY + + +arch = IfcElementAssemblyTypeEnum.ARCH + + +beam_grid = IfcElementAssemblyTypeEnum.BEAM_GRID + + +braced_frame = IfcElementAssemblyTypeEnum.BRACED_FRAME + + +girder = IfcElementAssemblyTypeEnum.GIRDER + + +reinforcement_unit = IfcElementAssemblyTypeEnum.REINFORCEMENT_UNIT + + +rigid_frame = IfcElementAssemblyTypeEnum.RIGID_FRAME + + +slab_field = IfcElementAssemblyTypeEnum.SLAB_FIELD + + +truss = IfcElementAssemblyTypeEnum.TRUSS + + +abutment = IfcElementAssemblyTypeEnum.ABUTMENT + + +pier = IfcElementAssemblyTypeEnum.PIER + + +pylon = IfcElementAssemblyTypeEnum.PYLON + + +cross_bracing = IfcElementAssemblyTypeEnum.CROSS_BRACING + + +deck = IfcElementAssemblyTypeEnum.DECK + + +userdefined = IfcElementAssemblyTypeEnum.USERDEFINED + + +notdefined = IfcElementAssemblyTypeEnum.NOTDEFINED + + +IfcElementCompositionEnum = enum_namespace() + + +complex = IfcElementCompositionEnum.COMPLEX + + +element = IfcElementCompositionEnum.ELEMENT + + +partial = IfcElementCompositionEnum.PARTIAL + + +IfcEngineTypeEnum = enum_namespace() + + +externalcombustion = IfcEngineTypeEnum.EXTERNALCOMBUSTION + + +internalcombustion = IfcEngineTypeEnum.INTERNALCOMBUSTION + + +userdefined = IfcEngineTypeEnum.USERDEFINED + + +notdefined = IfcEngineTypeEnum.NOTDEFINED + + +IfcEvaporativeCoolerTypeEnum = enum_namespace() + + +directevaporativerandommediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER + + +directevaporativerigidmediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER + + +directevaporativeslingerspackagedaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER + + +directevaporativepackagedrotaryaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER + + +directevaporativeairwasher = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEAIRWASHER + + +indirectevaporativepackageaircooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEPACKAGEAIRCOOLER + + +indirectevaporativewetcoil = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEWETCOIL + + +indirectevaporativecoolingtowerorcoilcooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER + + +indirectdirectcombination = IfcEvaporativeCoolerTypeEnum.INDIRECTDIRECTCOMBINATION + + +userdefined = IfcEvaporativeCoolerTypeEnum.USERDEFINED + + +notdefined = IfcEvaporativeCoolerTypeEnum.NOTDEFINED + + +IfcEvaporatorTypeEnum = enum_namespace() + + +directexpansion = IfcEvaporatorTypeEnum.DIRECTEXPANSION + + +directexpansionshellandtube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONSHELLANDTUBE + + +directexpansiontubeintube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONTUBEINTUBE + + +directexpansionbrazedplate = IfcEvaporatorTypeEnum.DIRECTEXPANSIONBRAZEDPLATE + + +floodedshellandtube = IfcEvaporatorTypeEnum.FLOODEDSHELLANDTUBE + + +shellandcoil = IfcEvaporatorTypeEnum.SHELLANDCOIL + + +userdefined = IfcEvaporatorTypeEnum.USERDEFINED + + +notdefined = IfcEvaporatorTypeEnum.NOTDEFINED + + +IfcEventTriggerTypeEnum = enum_namespace() + + +eventrule = IfcEventTriggerTypeEnum.EVENTRULE + + +eventmessage = IfcEventTriggerTypeEnum.EVENTMESSAGE + + +eventtime = IfcEventTriggerTypeEnum.EVENTTIME + + +eventcomplex = IfcEventTriggerTypeEnum.EVENTCOMPLEX + + +userdefined = IfcEventTriggerTypeEnum.USERDEFINED + + +notdefined = IfcEventTriggerTypeEnum.NOTDEFINED + + +IfcEventTypeEnum = enum_namespace() + + +startevent = IfcEventTypeEnum.STARTEVENT + + +endevent = IfcEventTypeEnum.ENDEVENT + + +intermediateevent = IfcEventTypeEnum.INTERMEDIATEEVENT + + +userdefined = IfcEventTypeEnum.USERDEFINED + + +notdefined = IfcEventTypeEnum.NOTDEFINED + + +IfcExternalSpatialElementTypeEnum = enum_namespace() + + +external = IfcExternalSpatialElementTypeEnum.EXTERNAL + + +external_earth = IfcExternalSpatialElementTypeEnum.EXTERNAL_EARTH + + +external_water = IfcExternalSpatialElementTypeEnum.EXTERNAL_WATER + + +external_fire = IfcExternalSpatialElementTypeEnum.EXTERNAL_FIRE + + +userdefined = IfcExternalSpatialElementTypeEnum.USERDEFINED + + +notdefined = IfcExternalSpatialElementTypeEnum.NOTDEFINED + + +IfcFanTypeEnum = enum_namespace() + + +centrifugalforwardcurved = IfcFanTypeEnum.CENTRIFUGALFORWARDCURVED + + +centrifugalradial = IfcFanTypeEnum.CENTRIFUGALRADIAL + + +centrifugalbackwardinclinedcurved = IfcFanTypeEnum.CENTRIFUGALBACKWARDINCLINEDCURVED + + +centrifugalairfoil = IfcFanTypeEnum.CENTRIFUGALAIRFOIL + + +tubeaxial = IfcFanTypeEnum.TUBEAXIAL + + +vaneaxial = IfcFanTypeEnum.VANEAXIAL + + +propelloraxial = IfcFanTypeEnum.PROPELLORAXIAL + + +userdefined = IfcFanTypeEnum.USERDEFINED + + +notdefined = IfcFanTypeEnum.NOTDEFINED + + +IfcFastenerTypeEnum = enum_namespace() + + +glue = IfcFastenerTypeEnum.GLUE + + +mortar = IfcFastenerTypeEnum.MORTAR + + +weld = IfcFastenerTypeEnum.WELD + + +userdefined = IfcFastenerTypeEnum.USERDEFINED + + +notdefined = IfcFastenerTypeEnum.NOTDEFINED + + +IfcFilterTypeEnum = enum_namespace() + + +airparticlefilter = IfcFilterTypeEnum.AIRPARTICLEFILTER + + +compressedairfilter = IfcFilterTypeEnum.COMPRESSEDAIRFILTER + + +odorfilter = IfcFilterTypeEnum.ODORFILTER + + +oilfilter = IfcFilterTypeEnum.OILFILTER + + +strainer = IfcFilterTypeEnum.STRAINER + + +waterfilter = IfcFilterTypeEnum.WATERFILTER + + +userdefined = IfcFilterTypeEnum.USERDEFINED + + +notdefined = IfcFilterTypeEnum.NOTDEFINED + + +IfcFireSuppressionTerminalTypeEnum = enum_namespace() + + +breechinginlet = IfcFireSuppressionTerminalTypeEnum.BREECHINGINLET + + +firehydrant = IfcFireSuppressionTerminalTypeEnum.FIREHYDRANT + + +hosereel = IfcFireSuppressionTerminalTypeEnum.HOSEREEL + + +sprinkler = IfcFireSuppressionTerminalTypeEnum.SPRINKLER + + +sprinklerdeflector = IfcFireSuppressionTerminalTypeEnum.SPRINKLERDEFLECTOR + + +userdefined = IfcFireSuppressionTerminalTypeEnum.USERDEFINED + + +notdefined = IfcFireSuppressionTerminalTypeEnum.NOTDEFINED + + +IfcFlowDirectionEnum = enum_namespace() + + +source = IfcFlowDirectionEnum.SOURCE + + +sink = IfcFlowDirectionEnum.SINK + + +sourceandsink = IfcFlowDirectionEnum.SOURCEANDSINK + + +notdefined = IfcFlowDirectionEnum.NOTDEFINED + + +IfcFlowInstrumentTypeEnum = enum_namespace() + + +pressuregauge = IfcFlowInstrumentTypeEnum.PRESSUREGAUGE + + +thermometer = IfcFlowInstrumentTypeEnum.THERMOMETER + + +ammeter = IfcFlowInstrumentTypeEnum.AMMETER + + +frequencymeter = IfcFlowInstrumentTypeEnum.FREQUENCYMETER + + +powerfactormeter = IfcFlowInstrumentTypeEnum.POWERFACTORMETER + + +phaseanglemeter = IfcFlowInstrumentTypeEnum.PHASEANGLEMETER + + +voltmeter_peak = IfcFlowInstrumentTypeEnum.VOLTMETER_PEAK + + +voltmeter_rms = IfcFlowInstrumentTypeEnum.VOLTMETER_RMS + + +userdefined = IfcFlowInstrumentTypeEnum.USERDEFINED + + +notdefined = IfcFlowInstrumentTypeEnum.NOTDEFINED + + +IfcFlowMeterTypeEnum = enum_namespace() + + +energymeter = IfcFlowMeterTypeEnum.ENERGYMETER + + +gasmeter = IfcFlowMeterTypeEnum.GASMETER + + +oilmeter = IfcFlowMeterTypeEnum.OILMETER + + +watermeter = IfcFlowMeterTypeEnum.WATERMETER + + +userdefined = IfcFlowMeterTypeEnum.USERDEFINED + + +notdefined = IfcFlowMeterTypeEnum.NOTDEFINED + + +IfcFootingTypeEnum = enum_namespace() + + +caisson_foundation = IfcFootingTypeEnum.CAISSON_FOUNDATION + + +footing_beam = IfcFootingTypeEnum.FOOTING_BEAM + + +pad_footing = IfcFootingTypeEnum.PAD_FOOTING + + +pile_cap = IfcFootingTypeEnum.PILE_CAP + + +strip_footing = IfcFootingTypeEnum.STRIP_FOOTING + + +userdefined = IfcFootingTypeEnum.USERDEFINED + + +notdefined = IfcFootingTypeEnum.NOTDEFINED + + +IfcFurnitureTypeEnum = enum_namespace() + + +chair = IfcFurnitureTypeEnum.CHAIR + + +table = IfcFurnitureTypeEnum.TABLE + + +desk = IfcFurnitureTypeEnum.DESK + + +bed = IfcFurnitureTypeEnum.BED + + +filecabinet = IfcFurnitureTypeEnum.FILECABINET + + +shelf = IfcFurnitureTypeEnum.SHELF + + +sofa = IfcFurnitureTypeEnum.SOFA + + +userdefined = IfcFurnitureTypeEnum.USERDEFINED + + +notdefined = IfcFurnitureTypeEnum.NOTDEFINED + + +IfcGeographicElementTypeEnum = enum_namespace() + + +terrain = IfcGeographicElementTypeEnum.TERRAIN + + +soil_boring_point = IfcGeographicElementTypeEnum.SOIL_BORING_POINT + + +userdefined = IfcGeographicElementTypeEnum.USERDEFINED + + +notdefined = IfcGeographicElementTypeEnum.NOTDEFINED + + +IfcGeometricProjectionEnum = enum_namespace() + + +graph_view = IfcGeometricProjectionEnum.GRAPH_VIEW + + +sketch_view = IfcGeometricProjectionEnum.SKETCH_VIEW + + +model_view = IfcGeometricProjectionEnum.MODEL_VIEW + + +plan_view = IfcGeometricProjectionEnum.PLAN_VIEW + + +reflected_plan_view = IfcGeometricProjectionEnum.REFLECTED_PLAN_VIEW + + +section_view = IfcGeometricProjectionEnum.SECTION_VIEW + + +elevation_view = IfcGeometricProjectionEnum.ELEVATION_VIEW + + +userdefined = IfcGeometricProjectionEnum.USERDEFINED + + +notdefined = IfcGeometricProjectionEnum.NOTDEFINED + + +IfcGlobalOrLocalEnum = enum_namespace() + + +global_coords = IfcGlobalOrLocalEnum.GLOBAL_COORDS + + +local_coords = IfcGlobalOrLocalEnum.LOCAL_COORDS + + +IfcGridTypeEnum = enum_namespace() + + +rectangular = IfcGridTypeEnum.RECTANGULAR + + +radial = IfcGridTypeEnum.RADIAL + + +triangular = IfcGridTypeEnum.TRIANGULAR + + +irregular = IfcGridTypeEnum.IRREGULAR + + +userdefined = IfcGridTypeEnum.USERDEFINED + + +notdefined = IfcGridTypeEnum.NOTDEFINED + + +IfcHeatExchangerTypeEnum = enum_namespace() + + +plate = IfcHeatExchangerTypeEnum.PLATE + + +shellandtube = IfcHeatExchangerTypeEnum.SHELLANDTUBE + + +userdefined = IfcHeatExchangerTypeEnum.USERDEFINED + + +notdefined = IfcHeatExchangerTypeEnum.NOTDEFINED + + +IfcHumidifierTypeEnum = enum_namespace() + + +steaminjection = IfcHumidifierTypeEnum.STEAMINJECTION + + +adiabaticairwasher = IfcHumidifierTypeEnum.ADIABATICAIRWASHER + + +adiabaticpan = IfcHumidifierTypeEnum.ADIABATICPAN + + +adiabaticwettedelement = IfcHumidifierTypeEnum.ADIABATICWETTEDELEMENT + + +adiabaticatomizing = IfcHumidifierTypeEnum.ADIABATICATOMIZING + + +adiabaticultrasonic = IfcHumidifierTypeEnum.ADIABATICULTRASONIC + + +adiabaticrigidmedia = IfcHumidifierTypeEnum.ADIABATICRIGIDMEDIA + + +adiabaticcompressedairnozzle = IfcHumidifierTypeEnum.ADIABATICCOMPRESSEDAIRNOZZLE + + +assistedelectric = IfcHumidifierTypeEnum.ASSISTEDELECTRIC + + +assistednaturalgas = IfcHumidifierTypeEnum.ASSISTEDNATURALGAS + + +assistedpropane = IfcHumidifierTypeEnum.ASSISTEDPROPANE + + +assistedbutane = IfcHumidifierTypeEnum.ASSISTEDBUTANE + + +assistedsteam = IfcHumidifierTypeEnum.ASSISTEDSTEAM + + +userdefined = IfcHumidifierTypeEnum.USERDEFINED + + +notdefined = IfcHumidifierTypeEnum.NOTDEFINED + + +IfcInterceptorTypeEnum = enum_namespace() + + +cyclonic = IfcInterceptorTypeEnum.CYCLONIC + + +grease = IfcInterceptorTypeEnum.GREASE + + +oil = IfcInterceptorTypeEnum.OIL + + +petrol = IfcInterceptorTypeEnum.PETROL + + +userdefined = IfcInterceptorTypeEnum.USERDEFINED + + +notdefined = IfcInterceptorTypeEnum.NOTDEFINED + + +IfcInternalOrExternalEnum = enum_namespace() + + +internal = IfcInternalOrExternalEnum.INTERNAL + + +external = IfcInternalOrExternalEnum.EXTERNAL + + +external_earth = IfcInternalOrExternalEnum.EXTERNAL_EARTH + + +external_water = IfcInternalOrExternalEnum.EXTERNAL_WATER + + +external_fire = IfcInternalOrExternalEnum.EXTERNAL_FIRE + + +notdefined = IfcInternalOrExternalEnum.NOTDEFINED + + +IfcInventoryTypeEnum = enum_namespace() + + +assetinventory = IfcInventoryTypeEnum.ASSETINVENTORY + + +spaceinventory = IfcInventoryTypeEnum.SPACEINVENTORY + + +furnitureinventory = IfcInventoryTypeEnum.FURNITUREINVENTORY + + +userdefined = IfcInventoryTypeEnum.USERDEFINED + + +notdefined = IfcInventoryTypeEnum.NOTDEFINED + + +IfcJunctionBoxTypeEnum = enum_namespace() + + +data = IfcJunctionBoxTypeEnum.DATA + + +power = IfcJunctionBoxTypeEnum.POWER + + +userdefined = IfcJunctionBoxTypeEnum.USERDEFINED + + +notdefined = IfcJunctionBoxTypeEnum.NOTDEFINED + + +IfcKnotType = enum_namespace() + + +uniform_knots = IfcKnotType.UNIFORM_KNOTS + + +quasi_uniform_knots = IfcKnotType.QUASI_UNIFORM_KNOTS + + +piecewise_bezier_knots = IfcKnotType.PIECEWISE_BEZIER_KNOTS + + +unspecified = IfcKnotType.UNSPECIFIED + + +IfcLaborResourceTypeEnum = enum_namespace() + + +administration = IfcLaborResourceTypeEnum.ADMINISTRATION + + +carpentry = IfcLaborResourceTypeEnum.CARPENTRY + + +cleaning = IfcLaborResourceTypeEnum.CLEANING + + +concrete = IfcLaborResourceTypeEnum.CONCRETE + + +drywall = IfcLaborResourceTypeEnum.DRYWALL + + +electric = IfcLaborResourceTypeEnum.ELECTRIC + + +finishing = IfcLaborResourceTypeEnum.FINISHING + + +flooring = IfcLaborResourceTypeEnum.FLOORING + + +general = IfcLaborResourceTypeEnum.GENERAL + + +hvac = IfcLaborResourceTypeEnum.HVAC + + +landscaping = IfcLaborResourceTypeEnum.LANDSCAPING + + +masonry = IfcLaborResourceTypeEnum.MASONRY + + +painting = IfcLaborResourceTypeEnum.PAINTING + + +paving = IfcLaborResourceTypeEnum.PAVING + + +plumbing = IfcLaborResourceTypeEnum.PLUMBING + + +roofing = IfcLaborResourceTypeEnum.ROOFING + + +sitegrading = IfcLaborResourceTypeEnum.SITEGRADING + + +steelwork = IfcLaborResourceTypeEnum.STEELWORK + + +surveying = IfcLaborResourceTypeEnum.SURVEYING + + +userdefined = IfcLaborResourceTypeEnum.USERDEFINED + + +notdefined = IfcLaborResourceTypeEnum.NOTDEFINED + + +IfcLampTypeEnum = enum_namespace() + + +compactfluorescent = IfcLampTypeEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLampTypeEnum.FLUORESCENT + + +halogen = IfcLampTypeEnum.HALOGEN + + +highpressuremercury = IfcLampTypeEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLampTypeEnum.HIGHPRESSURESODIUM + + +led = IfcLampTypeEnum.LED + + +metalhalide = IfcLampTypeEnum.METALHALIDE + + +oled = IfcLampTypeEnum.OLED + + +tungstenfilament = IfcLampTypeEnum.TUNGSTENFILAMENT + + +userdefined = IfcLampTypeEnum.USERDEFINED + + +notdefined = IfcLampTypeEnum.NOTDEFINED + + +IfcLayerSetDirectionEnum = enum_namespace() + + +axis1 = IfcLayerSetDirectionEnum.AXIS1 + + +axis2 = IfcLayerSetDirectionEnum.AXIS2 + + +axis3 = IfcLayerSetDirectionEnum.AXIS3 + + +IfcLightDistributionCurveEnum = enum_namespace() + + +type_a = IfcLightDistributionCurveEnum.TYPE_A + + +type_b = IfcLightDistributionCurveEnum.TYPE_B + + +type_c = IfcLightDistributionCurveEnum.TYPE_C + + +notdefined = IfcLightDistributionCurveEnum.NOTDEFINED + + +IfcLightEmissionSourceEnum = enum_namespace() + + +compactfluorescent = IfcLightEmissionSourceEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLightEmissionSourceEnum.FLUORESCENT + + +highpressuremercury = IfcLightEmissionSourceEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLightEmissionSourceEnum.HIGHPRESSURESODIUM + + +lightemittingdiode = IfcLightEmissionSourceEnum.LIGHTEMITTINGDIODE + + +lowpressuresodium = IfcLightEmissionSourceEnum.LOWPRESSURESODIUM + + +lowvoltagehalogen = IfcLightEmissionSourceEnum.LOWVOLTAGEHALOGEN + + +mainvoltagehalogen = IfcLightEmissionSourceEnum.MAINVOLTAGEHALOGEN + + +metalhalide = IfcLightEmissionSourceEnum.METALHALIDE + + +tungstenfilament = IfcLightEmissionSourceEnum.TUNGSTENFILAMENT + + +notdefined = IfcLightEmissionSourceEnum.NOTDEFINED + + +IfcLightFixtureTypeEnum = enum_namespace() + + +pointsource = IfcLightFixtureTypeEnum.POINTSOURCE + + +directionsource = IfcLightFixtureTypeEnum.DIRECTIONSOURCE + + +securitylighting = IfcLightFixtureTypeEnum.SECURITYLIGHTING + + +userdefined = IfcLightFixtureTypeEnum.USERDEFINED + + +notdefined = IfcLightFixtureTypeEnum.NOTDEFINED + + +IfcLoadGroupTypeEnum = enum_namespace() + + +load_group = IfcLoadGroupTypeEnum.LOAD_GROUP + + +load_case = IfcLoadGroupTypeEnum.LOAD_CASE + + +load_combination = IfcLoadGroupTypeEnum.LOAD_COMBINATION + + +userdefined = IfcLoadGroupTypeEnum.USERDEFINED + + +notdefined = IfcLoadGroupTypeEnum.NOTDEFINED + + +IfcLogicalOperatorEnum = enum_namespace() + + +logicaland = IfcLogicalOperatorEnum.LOGICALAND + + +logicalor = IfcLogicalOperatorEnum.LOGICALOR + + +logicalxor = IfcLogicalOperatorEnum.LOGICALXOR + + +logicalnotand = IfcLogicalOperatorEnum.LOGICALNOTAND + + +logicalnotor = IfcLogicalOperatorEnum.LOGICALNOTOR + + +IfcMechanicalFastenerTypeEnum = enum_namespace() + + +anchorbolt = IfcMechanicalFastenerTypeEnum.ANCHORBOLT + + +bolt = IfcMechanicalFastenerTypeEnum.BOLT + + +dowel = IfcMechanicalFastenerTypeEnum.DOWEL + + +nail = IfcMechanicalFastenerTypeEnum.NAIL + + +nailplate = IfcMechanicalFastenerTypeEnum.NAILPLATE + + +rivet = IfcMechanicalFastenerTypeEnum.RIVET + + +screw = IfcMechanicalFastenerTypeEnum.SCREW + + +shearconnector = IfcMechanicalFastenerTypeEnum.SHEARCONNECTOR + + +staple = IfcMechanicalFastenerTypeEnum.STAPLE + + +studshearconnector = IfcMechanicalFastenerTypeEnum.STUDSHEARCONNECTOR + + +coupler = IfcMechanicalFastenerTypeEnum.COUPLER + + +userdefined = IfcMechanicalFastenerTypeEnum.USERDEFINED + + +notdefined = IfcMechanicalFastenerTypeEnum.NOTDEFINED + + +IfcMedicalDeviceTypeEnum = enum_namespace() + + +airstation = IfcMedicalDeviceTypeEnum.AIRSTATION + + +feedairunit = IfcMedicalDeviceTypeEnum.FEEDAIRUNIT + + +oxygengenerator = IfcMedicalDeviceTypeEnum.OXYGENGENERATOR + + +oxygenplant = IfcMedicalDeviceTypeEnum.OXYGENPLANT + + +vacuumstation = IfcMedicalDeviceTypeEnum.VACUUMSTATION + + +userdefined = IfcMedicalDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMedicalDeviceTypeEnum.NOTDEFINED + + +IfcMemberTypeEnum = enum_namespace() + + +brace = IfcMemberTypeEnum.BRACE + + +chord = IfcMemberTypeEnum.CHORD + + +collar = IfcMemberTypeEnum.COLLAR + + +member = IfcMemberTypeEnum.MEMBER + + +mullion = IfcMemberTypeEnum.MULLION + + +plate = IfcMemberTypeEnum.PLATE + + +post = IfcMemberTypeEnum.POST + + +purlin = IfcMemberTypeEnum.PURLIN + + +rafter = IfcMemberTypeEnum.RAFTER + + +stringer = IfcMemberTypeEnum.STRINGER + + +strut = IfcMemberTypeEnum.STRUT + + +stud = IfcMemberTypeEnum.STUD + + +stiffening_rib = IfcMemberTypeEnum.STIFFENING_RIB + + +arch_segment = IfcMemberTypeEnum.ARCH_SEGMENT + + +suspension_cable = IfcMemberTypeEnum.SUSPENSION_CABLE + + +suspender = IfcMemberTypeEnum.SUSPENDER + + +stay_cable = IfcMemberTypeEnum.STAY_CABLE + + +userdefined = IfcMemberTypeEnum.USERDEFINED + + +notdefined = IfcMemberTypeEnum.NOTDEFINED + + +IfcMotorConnectionTypeEnum = enum_namespace() + + +beltdrive = IfcMotorConnectionTypeEnum.BELTDRIVE + + +coupling = IfcMotorConnectionTypeEnum.COUPLING + + +directdrive = IfcMotorConnectionTypeEnum.DIRECTDRIVE + + +userdefined = IfcMotorConnectionTypeEnum.USERDEFINED + + +notdefined = IfcMotorConnectionTypeEnum.NOTDEFINED + + +IfcNullStyle = enum_namespace() + + +null = IfcNullStyle.NULL + + +IfcObjectTypeEnum = enum_namespace() + + +product = IfcObjectTypeEnum.PRODUCT + + +process = IfcObjectTypeEnum.PROCESS + + +control = IfcObjectTypeEnum.CONTROL + + +resource = IfcObjectTypeEnum.RESOURCE + + +actor = IfcObjectTypeEnum.ACTOR + + +group = IfcObjectTypeEnum.GROUP + + +project = IfcObjectTypeEnum.PROJECT + + +notdefined = IfcObjectTypeEnum.NOTDEFINED + + +IfcObjectiveEnum = enum_namespace() + + +codecompliance = IfcObjectiveEnum.CODECOMPLIANCE + + +codewaiver = IfcObjectiveEnum.CODEWAIVER + + +designintent = IfcObjectiveEnum.DESIGNINTENT + + +external = IfcObjectiveEnum.EXTERNAL + + +healthandsafety = IfcObjectiveEnum.HEALTHANDSAFETY + + +mergeconflict = IfcObjectiveEnum.MERGECONFLICT + + +modelview = IfcObjectiveEnum.MODELVIEW + + +parameter = IfcObjectiveEnum.PARAMETER + + +requirement = IfcObjectiveEnum.REQUIREMENT + + +specification = IfcObjectiveEnum.SPECIFICATION + + +triggercondition = IfcObjectiveEnum.TRIGGERCONDITION + + +userdefined = IfcObjectiveEnum.USERDEFINED + + +notdefined = IfcObjectiveEnum.NOTDEFINED + + +IfcOccupantTypeEnum = enum_namespace() + + +assignee = IfcOccupantTypeEnum.ASSIGNEE + + +assignor = IfcOccupantTypeEnum.ASSIGNOR + + +lessee = IfcOccupantTypeEnum.LESSEE + + +lessor = IfcOccupantTypeEnum.LESSOR + + +lettingagent = IfcOccupantTypeEnum.LETTINGAGENT + + +owner = IfcOccupantTypeEnum.OWNER + + +tenant = IfcOccupantTypeEnum.TENANT + + +userdefined = IfcOccupantTypeEnum.USERDEFINED + + +notdefined = IfcOccupantTypeEnum.NOTDEFINED + + +IfcOpeningElementTypeEnum = enum_namespace() + + +opening = IfcOpeningElementTypeEnum.OPENING + + +recess = IfcOpeningElementTypeEnum.RECESS + + +userdefined = IfcOpeningElementTypeEnum.USERDEFINED + + +notdefined = IfcOpeningElementTypeEnum.NOTDEFINED + + +IfcOutletTypeEnum = enum_namespace() + + +audiovisualoutlet = IfcOutletTypeEnum.AUDIOVISUALOUTLET + + +communicationsoutlet = IfcOutletTypeEnum.COMMUNICATIONSOUTLET + + +poweroutlet = IfcOutletTypeEnum.POWEROUTLET + + +dataoutlet = IfcOutletTypeEnum.DATAOUTLET + + +telephoneoutlet = IfcOutletTypeEnum.TELEPHONEOUTLET + + +userdefined = IfcOutletTypeEnum.USERDEFINED + + +notdefined = IfcOutletTypeEnum.NOTDEFINED + + +IfcPerformanceHistoryTypeEnum = enum_namespace() + + +userdefined = IfcPerformanceHistoryTypeEnum.USERDEFINED + + +notdefined = IfcPerformanceHistoryTypeEnum.NOTDEFINED + + +IfcPermeableCoveringOperationEnum = enum_namespace() + + +grill = IfcPermeableCoveringOperationEnum.GRILL + + +louver = IfcPermeableCoveringOperationEnum.LOUVER + + +screen = IfcPermeableCoveringOperationEnum.SCREEN + + +userdefined = IfcPermeableCoveringOperationEnum.USERDEFINED + + +notdefined = IfcPermeableCoveringOperationEnum.NOTDEFINED + + +IfcPermitTypeEnum = enum_namespace() + + +access = IfcPermitTypeEnum.ACCESS + + +building = IfcPermitTypeEnum.BUILDING + + +work = IfcPermitTypeEnum.WORK + + +userdefined = IfcPermitTypeEnum.USERDEFINED + + +notdefined = IfcPermitTypeEnum.NOTDEFINED + + +IfcPhysicalOrVirtualEnum = enum_namespace() + + +physical = IfcPhysicalOrVirtualEnum.PHYSICAL + + +virtual = IfcPhysicalOrVirtualEnum.VIRTUAL + + +notdefined = IfcPhysicalOrVirtualEnum.NOTDEFINED + + +IfcPileConstructionEnum = enum_namespace() + + +cast_in_place = IfcPileConstructionEnum.CAST_IN_PLACE + + +composite = IfcPileConstructionEnum.COMPOSITE + + +precast_concrete = IfcPileConstructionEnum.PRECAST_CONCRETE + + +prefab_steel = IfcPileConstructionEnum.PREFAB_STEEL + + +userdefined = IfcPileConstructionEnum.USERDEFINED + + +notdefined = IfcPileConstructionEnum.NOTDEFINED + + +IfcPileTypeEnum = enum_namespace() + + +bored = IfcPileTypeEnum.BORED + + +driven = IfcPileTypeEnum.DRIVEN + + +jetgrouting = IfcPileTypeEnum.JETGROUTING + + +cohesion = IfcPileTypeEnum.COHESION + + +friction = IfcPileTypeEnum.FRICTION + + +support = IfcPileTypeEnum.SUPPORT + + +userdefined = IfcPileTypeEnum.USERDEFINED + + +notdefined = IfcPileTypeEnum.NOTDEFINED + + +IfcPipeFittingTypeEnum = enum_namespace() + + +bend = IfcPipeFittingTypeEnum.BEND + + +connector = IfcPipeFittingTypeEnum.CONNECTOR + + +entry = IfcPipeFittingTypeEnum.ENTRY + + +exit = IfcPipeFittingTypeEnum.EXIT + + +junction = IfcPipeFittingTypeEnum.JUNCTION + + +obstruction = IfcPipeFittingTypeEnum.OBSTRUCTION + + +transition = IfcPipeFittingTypeEnum.TRANSITION + + +userdefined = IfcPipeFittingTypeEnum.USERDEFINED + + +notdefined = IfcPipeFittingTypeEnum.NOTDEFINED + + +IfcPipeSegmentTypeEnum = enum_namespace() + + +culvert = IfcPipeSegmentTypeEnum.CULVERT + + +flexiblesegment = IfcPipeSegmentTypeEnum.FLEXIBLESEGMENT + + +rigidsegment = IfcPipeSegmentTypeEnum.RIGIDSEGMENT + + +gutter = IfcPipeSegmentTypeEnum.GUTTER + + +spool = IfcPipeSegmentTypeEnum.SPOOL + + +userdefined = IfcPipeSegmentTypeEnum.USERDEFINED + + +notdefined = IfcPipeSegmentTypeEnum.NOTDEFINED + + +IfcPlateTypeEnum = enum_namespace() + + +curtain_panel = IfcPlateTypeEnum.CURTAIN_PANEL + + +sheet = IfcPlateTypeEnum.SHEET + + +flange_plate = IfcPlateTypeEnum.FLANGE_PLATE + + +web_plate = IfcPlateTypeEnum.WEB_PLATE + + +stiffener_plate = IfcPlateTypeEnum.STIFFENER_PLATE + + +gusset_plate = IfcPlateTypeEnum.GUSSET_PLATE + + +cover_plate = IfcPlateTypeEnum.COVER_PLATE + + +splice_plate = IfcPlateTypeEnum.SPLICE_PLATE + + +base_plate = IfcPlateTypeEnum.BASE_PLATE + + +userdefined = IfcPlateTypeEnum.USERDEFINED + + +notdefined = IfcPlateTypeEnum.NOTDEFINED + + +IfcPreferredSurfaceCurveRepresentation = enum_namespace() + + +curve3d = IfcPreferredSurfaceCurveRepresentation.CURVE3D + + +pcurve_s1 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S1 + + +pcurve_s2 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S2 + + +IfcProcedureTypeEnum = enum_namespace() + + +advice_caution = IfcProcedureTypeEnum.ADVICE_CAUTION + + +advice_note = IfcProcedureTypeEnum.ADVICE_NOTE + + +advice_warning = IfcProcedureTypeEnum.ADVICE_WARNING + + +calibration = IfcProcedureTypeEnum.CALIBRATION + + +diagnostic = IfcProcedureTypeEnum.DIAGNOSTIC + + +shutdown = IfcProcedureTypeEnum.SHUTDOWN + + +startup = IfcProcedureTypeEnum.STARTUP + + +userdefined = IfcProcedureTypeEnum.USERDEFINED + + +notdefined = IfcProcedureTypeEnum.NOTDEFINED + + +IfcProfileTypeEnum = enum_namespace() + + +curve = IfcProfileTypeEnum.CURVE + + +area = IfcProfileTypeEnum.AREA + + +IfcProjectOrderTypeEnum = enum_namespace() + + +changeorder = IfcProjectOrderTypeEnum.CHANGEORDER + + +maintenanceworkorder = IfcProjectOrderTypeEnum.MAINTENANCEWORKORDER + + +moveorder = IfcProjectOrderTypeEnum.MOVEORDER + + +purchaseorder = IfcProjectOrderTypeEnum.PURCHASEORDER + + +workorder = IfcProjectOrderTypeEnum.WORKORDER + + +userdefined = IfcProjectOrderTypeEnum.USERDEFINED + + +notdefined = IfcProjectOrderTypeEnum.NOTDEFINED + + +IfcProjectedOrTrueLengthEnum = enum_namespace() + + +projected_length = IfcProjectedOrTrueLengthEnum.PROJECTED_LENGTH + + +true_length = IfcProjectedOrTrueLengthEnum.TRUE_LENGTH + + +IfcProjectionElementTypeEnum = enum_namespace() + + +blister = IfcProjectionElementTypeEnum.BLISTER + + +deviator = IfcProjectionElementTypeEnum.DEVIATOR + + +userdefined = IfcProjectionElementTypeEnum.USERDEFINED + + +notdefined = IfcProjectionElementTypeEnum.NOTDEFINED + + +IfcPropertySetTemplateTypeEnum = enum_namespace() + + +pset_typedrivenonly = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENONLY + + +pset_typedrivenoverride = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENOVERRIDE + + +pset_occurrencedriven = IfcPropertySetTemplateTypeEnum.PSET_OCCURRENCEDRIVEN + + +pset_performancedriven = IfcPropertySetTemplateTypeEnum.PSET_PERFORMANCEDRIVEN + + +qto_typedrivenonly = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENONLY + + +qto_typedrivenoverride = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENOVERRIDE + + +qto_occurrencedriven = IfcPropertySetTemplateTypeEnum.QTO_OCCURRENCEDRIVEN + + +notdefined = IfcPropertySetTemplateTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTrippingUnitTypeEnum = enum_namespace() + + +electronic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTRONIC + + +electromagnetic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTROMAGNETIC + + +residualcurrent = IfcProtectiveDeviceTrippingUnitTypeEnum.RESIDUALCURRENT + + +thermal = IfcProtectiveDeviceTrippingUnitTypeEnum.THERMAL + + +userdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTypeEnum = enum_namespace() + + +circuitbreaker = IfcProtectiveDeviceTypeEnum.CIRCUITBREAKER + + +earthleakagecircuitbreaker = IfcProtectiveDeviceTypeEnum.EARTHLEAKAGECIRCUITBREAKER + + +earthingswitch = IfcProtectiveDeviceTypeEnum.EARTHINGSWITCH + + +fusedisconnector = IfcProtectiveDeviceTypeEnum.FUSEDISCONNECTOR + + +residualcurrentcircuitbreaker = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTCIRCUITBREAKER + + +residualcurrentswitch = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTSWITCH + + +varistor = IfcProtectiveDeviceTypeEnum.VARISTOR + + +userdefined = IfcProtectiveDeviceTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTypeEnum.NOTDEFINED + + +IfcPumpTypeEnum = enum_namespace() + + +circulator = IfcPumpTypeEnum.CIRCULATOR + + +endsuction = IfcPumpTypeEnum.ENDSUCTION + + +splitcase = IfcPumpTypeEnum.SPLITCASE + + +submersiblepump = IfcPumpTypeEnum.SUBMERSIBLEPUMP + + +sumppump = IfcPumpTypeEnum.SUMPPUMP + + +verticalinline = IfcPumpTypeEnum.VERTICALINLINE + + +verticalturbine = IfcPumpTypeEnum.VERTICALTURBINE + + +userdefined = IfcPumpTypeEnum.USERDEFINED + + +notdefined = IfcPumpTypeEnum.NOTDEFINED + + +IfcRailingTypeEnum = enum_namespace() + + +handrail = IfcRailingTypeEnum.HANDRAIL + + +guardrail = IfcRailingTypeEnum.GUARDRAIL + + +balustrade = IfcRailingTypeEnum.BALUSTRADE + + +userdefined = IfcRailingTypeEnum.USERDEFINED + + +notdefined = IfcRailingTypeEnum.NOTDEFINED + + +IfcRampFlightTypeEnum = enum_namespace() + + +straight = IfcRampFlightTypeEnum.STRAIGHT + + +spiral = IfcRampFlightTypeEnum.SPIRAL + + +userdefined = IfcRampFlightTypeEnum.USERDEFINED + + +notdefined = IfcRampFlightTypeEnum.NOTDEFINED + + +IfcRampTypeEnum = enum_namespace() + + +straight_run_ramp = IfcRampTypeEnum.STRAIGHT_RUN_RAMP + + +two_straight_run_ramp = IfcRampTypeEnum.TWO_STRAIGHT_RUN_RAMP + + +quarter_turn_ramp = IfcRampTypeEnum.QUARTER_TURN_RAMP + + +two_quarter_turn_ramp = IfcRampTypeEnum.TWO_QUARTER_TURN_RAMP + + +half_turn_ramp = IfcRampTypeEnum.HALF_TURN_RAMP + + +spiral_ramp = IfcRampTypeEnum.SPIRAL_RAMP + + +userdefined = IfcRampTypeEnum.USERDEFINED + + +notdefined = IfcRampTypeEnum.NOTDEFINED + + +IfcRecurrenceTypeEnum = enum_namespace() + + +daily = IfcRecurrenceTypeEnum.DAILY + + +weekly = IfcRecurrenceTypeEnum.WEEKLY + + +monthly_by_day_of_month = IfcRecurrenceTypeEnum.MONTHLY_BY_DAY_OF_MONTH + + +monthly_by_position = IfcRecurrenceTypeEnum.MONTHLY_BY_POSITION + + +by_day_count = IfcRecurrenceTypeEnum.BY_DAY_COUNT + + +by_weekday_count = IfcRecurrenceTypeEnum.BY_WEEKDAY_COUNT + + +yearly_by_day_of_month = IfcRecurrenceTypeEnum.YEARLY_BY_DAY_OF_MONTH + + +yearly_by_position = IfcRecurrenceTypeEnum.YEARLY_BY_POSITION + + +IfcReferentTypeEnum = enum_namespace() + + +kilopoint = IfcReferentTypeEnum.KILOPOINT + + +milepoint = IfcReferentTypeEnum.MILEPOINT + + +station = IfcReferentTypeEnum.STATION + + +userdefined = IfcReferentTypeEnum.USERDEFINED + + +notdefined = IfcReferentTypeEnum.NOTDEFINED + + +IfcReflectanceMethodEnum = enum_namespace() + + +blinn = IfcReflectanceMethodEnum.BLINN + + +flat = IfcReflectanceMethodEnum.FLAT + + +glass = IfcReflectanceMethodEnum.GLASS + + +matt = IfcReflectanceMethodEnum.MATT + + +metal = IfcReflectanceMethodEnum.METAL + + +mirror = IfcReflectanceMethodEnum.MIRROR + + +phong = IfcReflectanceMethodEnum.PHONG + + +plastic = IfcReflectanceMethodEnum.PLASTIC + + +strauss = IfcReflectanceMethodEnum.STRAUSS + + +notdefined = IfcReflectanceMethodEnum.NOTDEFINED + + +IfcReinforcingBarRoleEnum = enum_namespace() + + +main = IfcReinforcingBarRoleEnum.MAIN + + +shear = IfcReinforcingBarRoleEnum.SHEAR + + +ligature = IfcReinforcingBarRoleEnum.LIGATURE + + +stud = IfcReinforcingBarRoleEnum.STUD + + +punching = IfcReinforcingBarRoleEnum.PUNCHING + + +edge = IfcReinforcingBarRoleEnum.EDGE + + +ring = IfcReinforcingBarRoleEnum.RING + + +anchoring = IfcReinforcingBarRoleEnum.ANCHORING + + +userdefined = IfcReinforcingBarRoleEnum.USERDEFINED + + +notdefined = IfcReinforcingBarRoleEnum.NOTDEFINED + + +IfcReinforcingBarSurfaceEnum = enum_namespace() + + +plain = IfcReinforcingBarSurfaceEnum.PLAIN + + +textured = IfcReinforcingBarSurfaceEnum.TEXTURED + + +IfcReinforcingBarTypeEnum = enum_namespace() + + +anchoring = IfcReinforcingBarTypeEnum.ANCHORING + + +edge = IfcReinforcingBarTypeEnum.EDGE + + +ligature = IfcReinforcingBarTypeEnum.LIGATURE + + +main = IfcReinforcingBarTypeEnum.MAIN + + +punching = IfcReinforcingBarTypeEnum.PUNCHING + + +ring = IfcReinforcingBarTypeEnum.RING + + +shear = IfcReinforcingBarTypeEnum.SHEAR + + +stud = IfcReinforcingBarTypeEnum.STUD + + +spacebar = IfcReinforcingBarTypeEnum.SPACEBAR + + +userdefined = IfcReinforcingBarTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingBarTypeEnum.NOTDEFINED + + +IfcReinforcingMeshTypeEnum = enum_namespace() + + +userdefined = IfcReinforcingMeshTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingMeshTypeEnum.NOTDEFINED + + +IfcRoleEnum = enum_namespace() + + +supplier = IfcRoleEnum.SUPPLIER + + +manufacturer = IfcRoleEnum.MANUFACTURER + + +contractor = IfcRoleEnum.CONTRACTOR + + +subcontractor = IfcRoleEnum.SUBCONTRACTOR + + +architect = IfcRoleEnum.ARCHITECT + + +structuralengineer = IfcRoleEnum.STRUCTURALENGINEER + + +costengineer = IfcRoleEnum.COSTENGINEER + + +client = IfcRoleEnum.CLIENT + + +buildingowner = IfcRoleEnum.BUILDINGOWNER + + +buildingoperator = IfcRoleEnum.BUILDINGOPERATOR + + +mechanicalengineer = IfcRoleEnum.MECHANICALENGINEER + + +electricalengineer = IfcRoleEnum.ELECTRICALENGINEER + + +projectmanager = IfcRoleEnum.PROJECTMANAGER + + +facilitiesmanager = IfcRoleEnum.FACILITIESMANAGER + + +civilengineer = IfcRoleEnum.CIVILENGINEER + + +commissioningengineer = IfcRoleEnum.COMMISSIONINGENGINEER + + +engineer = IfcRoleEnum.ENGINEER + + +owner = IfcRoleEnum.OWNER + + +consultant = IfcRoleEnum.CONSULTANT + + +constructionmanager = IfcRoleEnum.CONSTRUCTIONMANAGER + + +fieldconstructionmanager = IfcRoleEnum.FIELDCONSTRUCTIONMANAGER + + +reseller = IfcRoleEnum.RESELLER + + +userdefined = IfcRoleEnum.USERDEFINED + + +IfcRoofTypeEnum = enum_namespace() + + +flat_roof = IfcRoofTypeEnum.FLAT_ROOF + + +shed_roof = IfcRoofTypeEnum.SHED_ROOF + + +gable_roof = IfcRoofTypeEnum.GABLE_ROOF + + +hip_roof = IfcRoofTypeEnum.HIP_ROOF + + +hipped_gable_roof = IfcRoofTypeEnum.HIPPED_GABLE_ROOF + + +gambrel_roof = IfcRoofTypeEnum.GAMBREL_ROOF + + +mansard_roof = IfcRoofTypeEnum.MANSARD_ROOF + + +barrel_roof = IfcRoofTypeEnum.BARREL_ROOF + + +rainbow_roof = IfcRoofTypeEnum.RAINBOW_ROOF + + +butterfly_roof = IfcRoofTypeEnum.BUTTERFLY_ROOF + + +pavilion_roof = IfcRoofTypeEnum.PAVILION_ROOF + + +dome_roof = IfcRoofTypeEnum.DOME_ROOF + + +freeform = IfcRoofTypeEnum.FREEFORM + + +userdefined = IfcRoofTypeEnum.USERDEFINED + + +notdefined = IfcRoofTypeEnum.NOTDEFINED + + +IfcSIPrefix = enum_namespace() + + +exa = IfcSIPrefix.EXA + + +peta = IfcSIPrefix.PETA + + +tera = IfcSIPrefix.TERA + + +giga = IfcSIPrefix.GIGA + + +mega = IfcSIPrefix.MEGA + + +kilo = IfcSIPrefix.KILO + + +hecto = IfcSIPrefix.HECTO + + +deca = IfcSIPrefix.DECA + + +deci = IfcSIPrefix.DECI + + +centi = IfcSIPrefix.CENTI + + +milli = IfcSIPrefix.MILLI + + +micro = IfcSIPrefix.MICRO + + +nano = IfcSIPrefix.NANO + + +pico = IfcSIPrefix.PICO + + +femto = IfcSIPrefix.FEMTO + + +atto = IfcSIPrefix.ATTO + + +IfcSIUnitName = enum_namespace() + + +ampere = IfcSIUnitName.AMPERE + + +becquerel = IfcSIUnitName.BECQUEREL + + +candela = IfcSIUnitName.CANDELA + + +coulomb = IfcSIUnitName.COULOMB + + +cubic_metre = IfcSIUnitName.CUBIC_METRE + + +degree_celsius = IfcSIUnitName.DEGREE_CELSIUS + + +farad = IfcSIUnitName.FARAD + + +gram = IfcSIUnitName.GRAM + + +gray = IfcSIUnitName.GRAY + + +henry = IfcSIUnitName.HENRY + + +hertz = IfcSIUnitName.HERTZ + + +joule = IfcSIUnitName.JOULE + + +kelvin = IfcSIUnitName.KELVIN + + +lumen = IfcSIUnitName.LUMEN + + +lux = IfcSIUnitName.LUX + + +metre = IfcSIUnitName.METRE + + +mole = IfcSIUnitName.MOLE + + +newton = IfcSIUnitName.NEWTON + + +ohm = IfcSIUnitName.OHM + + +pascal = IfcSIUnitName.PASCAL + + +radian = IfcSIUnitName.RADIAN + + +second = IfcSIUnitName.SECOND + + +siemens = IfcSIUnitName.SIEMENS + + +sievert = IfcSIUnitName.SIEVERT + + +square_metre = IfcSIUnitName.SQUARE_METRE + + +steradian = IfcSIUnitName.STERADIAN + + +tesla = IfcSIUnitName.TESLA + + +volt = IfcSIUnitName.VOLT + + +watt = IfcSIUnitName.WATT + + +weber = IfcSIUnitName.WEBER + + +IfcSanitaryTerminalTypeEnum = enum_namespace() + + +bath = IfcSanitaryTerminalTypeEnum.BATH + + +bidet = IfcSanitaryTerminalTypeEnum.BIDET + + +cistern = IfcSanitaryTerminalTypeEnum.CISTERN + + +shower = IfcSanitaryTerminalTypeEnum.SHOWER + + +sink = IfcSanitaryTerminalTypeEnum.SINK + + +sanitaryfountain = IfcSanitaryTerminalTypeEnum.SANITARYFOUNTAIN + + +toiletpan = IfcSanitaryTerminalTypeEnum.TOILETPAN + + +urinal = IfcSanitaryTerminalTypeEnum.URINAL + + +washhandbasin = IfcSanitaryTerminalTypeEnum.WASHHANDBASIN + + +wcseat = IfcSanitaryTerminalTypeEnum.WCSEAT + + +userdefined = IfcSanitaryTerminalTypeEnum.USERDEFINED + + +notdefined = IfcSanitaryTerminalTypeEnum.NOTDEFINED + + +IfcSectionTypeEnum = enum_namespace() + + +uniform = IfcSectionTypeEnum.UNIFORM + + +tapered = IfcSectionTypeEnum.TAPERED + + +IfcSensorTypeEnum = enum_namespace() + + +cosensor = IfcSensorTypeEnum.COSENSOR + + +co2sensor = IfcSensorTypeEnum.CO2SENSOR + + +conductancesensor = IfcSensorTypeEnum.CONDUCTANCESENSOR + + +contactsensor = IfcSensorTypeEnum.CONTACTSENSOR + + +firesensor = IfcSensorTypeEnum.FIRESENSOR + + +flowsensor = IfcSensorTypeEnum.FLOWSENSOR + + +frostsensor = IfcSensorTypeEnum.FROSTSENSOR + + +gassensor = IfcSensorTypeEnum.GASSENSOR + + +heatsensor = IfcSensorTypeEnum.HEATSENSOR + + +humiditysensor = IfcSensorTypeEnum.HUMIDITYSENSOR + + +identifiersensor = IfcSensorTypeEnum.IDENTIFIERSENSOR + + +ionconcentrationsensor = IfcSensorTypeEnum.IONCONCENTRATIONSENSOR + + +levelsensor = IfcSensorTypeEnum.LEVELSENSOR + + +lightsensor = IfcSensorTypeEnum.LIGHTSENSOR + + +moisturesensor = IfcSensorTypeEnum.MOISTURESENSOR + + +movementsensor = IfcSensorTypeEnum.MOVEMENTSENSOR + + +phsensor = IfcSensorTypeEnum.PHSENSOR + + +pressuresensor = IfcSensorTypeEnum.PRESSURESENSOR + + +radiationsensor = IfcSensorTypeEnum.RADIATIONSENSOR + + +radioactivitysensor = IfcSensorTypeEnum.RADIOACTIVITYSENSOR + + +smokesensor = IfcSensorTypeEnum.SMOKESENSOR + + +soundsensor = IfcSensorTypeEnum.SOUNDSENSOR + + +temperaturesensor = IfcSensorTypeEnum.TEMPERATURESENSOR + + +windsensor = IfcSensorTypeEnum.WINDSENSOR + + +userdefined = IfcSensorTypeEnum.USERDEFINED + + +notdefined = IfcSensorTypeEnum.NOTDEFINED + + +IfcSequenceEnum = enum_namespace() + + +start_start = IfcSequenceEnum.START_START + + +start_finish = IfcSequenceEnum.START_FINISH + + +finish_start = IfcSequenceEnum.FINISH_START + + +finish_finish = IfcSequenceEnum.FINISH_FINISH + + +userdefined = IfcSequenceEnum.USERDEFINED + + +notdefined = IfcSequenceEnum.NOTDEFINED + + +IfcShadingDeviceTypeEnum = enum_namespace() + + +jalousie = IfcShadingDeviceTypeEnum.JALOUSIE + + +shutter = IfcShadingDeviceTypeEnum.SHUTTER + + +awning = IfcShadingDeviceTypeEnum.AWNING + + +userdefined = IfcShadingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcShadingDeviceTypeEnum.NOTDEFINED + + +IfcSimplePropertyTemplateTypeEnum = enum_namespace() + + +p_singlevalue = IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE + + +p_enumeratedvalue = IfcSimplePropertyTemplateTypeEnum.P_ENUMERATEDVALUE + + +p_boundedvalue = IfcSimplePropertyTemplateTypeEnum.P_BOUNDEDVALUE + + +p_listvalue = IfcSimplePropertyTemplateTypeEnum.P_LISTVALUE + + +p_tablevalue = IfcSimplePropertyTemplateTypeEnum.P_TABLEVALUE + + +p_referencevalue = IfcSimplePropertyTemplateTypeEnum.P_REFERENCEVALUE + + +q_length = IfcSimplePropertyTemplateTypeEnum.Q_LENGTH + + +q_area = IfcSimplePropertyTemplateTypeEnum.Q_AREA + + +q_volume = IfcSimplePropertyTemplateTypeEnum.Q_VOLUME + + +q_count = IfcSimplePropertyTemplateTypeEnum.Q_COUNT + + +q_weight = IfcSimplePropertyTemplateTypeEnum.Q_WEIGHT + + +q_time = IfcSimplePropertyTemplateTypeEnum.Q_TIME + + +IfcSlabTypeEnum = enum_namespace() + + +floor = IfcSlabTypeEnum.FLOOR + + +roof = IfcSlabTypeEnum.ROOF + + +landing = IfcSlabTypeEnum.LANDING + + +baseslab = IfcSlabTypeEnum.BASESLAB + + +approach_slab = IfcSlabTypeEnum.APPROACH_SLAB + + +paving = IfcSlabTypeEnum.PAVING + + +wearing = IfcSlabTypeEnum.WEARING + + +sidewalk = IfcSlabTypeEnum.SIDEWALK + + +userdefined = IfcSlabTypeEnum.USERDEFINED + + +notdefined = IfcSlabTypeEnum.NOTDEFINED + + +IfcSolarDeviceTypeEnum = enum_namespace() + + +solarcollector = IfcSolarDeviceTypeEnum.SOLARCOLLECTOR + + +solarpanel = IfcSolarDeviceTypeEnum.SOLARPANEL + + +userdefined = IfcSolarDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSolarDeviceTypeEnum.NOTDEFINED + + +IfcSpaceHeaterTypeEnum = enum_namespace() + + +convector = IfcSpaceHeaterTypeEnum.CONVECTOR + + +radiator = IfcSpaceHeaterTypeEnum.RADIATOR + + +userdefined = IfcSpaceHeaterTypeEnum.USERDEFINED + + +notdefined = IfcSpaceHeaterTypeEnum.NOTDEFINED + + +IfcSpaceTypeEnum = enum_namespace() + + +space = IfcSpaceTypeEnum.SPACE + + +parking = IfcSpaceTypeEnum.PARKING + + +gfa = IfcSpaceTypeEnum.GFA + + +internal = IfcSpaceTypeEnum.INTERNAL + + +external = IfcSpaceTypeEnum.EXTERNAL + + +userdefined = IfcSpaceTypeEnum.USERDEFINED + + +notdefined = IfcSpaceTypeEnum.NOTDEFINED + + +IfcSpatialZoneTypeEnum = enum_namespace() + + +construction = IfcSpatialZoneTypeEnum.CONSTRUCTION + + +firesafety = IfcSpatialZoneTypeEnum.FIRESAFETY + + +lighting = IfcSpatialZoneTypeEnum.LIGHTING + + +occupancy = IfcSpatialZoneTypeEnum.OCCUPANCY + + +security = IfcSpatialZoneTypeEnum.SECURITY + + +thermal = IfcSpatialZoneTypeEnum.THERMAL + + +transport = IfcSpatialZoneTypeEnum.TRANSPORT + + +ventilation = IfcSpatialZoneTypeEnum.VENTILATION + + +userdefined = IfcSpatialZoneTypeEnum.USERDEFINED + + +notdefined = IfcSpatialZoneTypeEnum.NOTDEFINED + + +IfcStackTerminalTypeEnum = enum_namespace() + + +birdcage = IfcStackTerminalTypeEnum.BIRDCAGE + + +cowl = IfcStackTerminalTypeEnum.COWL + + +rainwaterhopper = IfcStackTerminalTypeEnum.RAINWATERHOPPER + + +userdefined = IfcStackTerminalTypeEnum.USERDEFINED + + +notdefined = IfcStackTerminalTypeEnum.NOTDEFINED + + +IfcStairFlightTypeEnum = enum_namespace() + + +straight = IfcStairFlightTypeEnum.STRAIGHT + + +winder = IfcStairFlightTypeEnum.WINDER + + +spiral = IfcStairFlightTypeEnum.SPIRAL + + +curved = IfcStairFlightTypeEnum.CURVED + + +freeform = IfcStairFlightTypeEnum.FREEFORM + + +userdefined = IfcStairFlightTypeEnum.USERDEFINED + + +notdefined = IfcStairFlightTypeEnum.NOTDEFINED + + +IfcStairTypeEnum = enum_namespace() + + +straight_run_stair = IfcStairTypeEnum.STRAIGHT_RUN_STAIR + + +two_straight_run_stair = IfcStairTypeEnum.TWO_STRAIGHT_RUN_STAIR + + +quarter_winding_stair = IfcStairTypeEnum.QUARTER_WINDING_STAIR + + +quarter_turn_stair = IfcStairTypeEnum.QUARTER_TURN_STAIR + + +half_winding_stair = IfcStairTypeEnum.HALF_WINDING_STAIR + + +half_turn_stair = IfcStairTypeEnum.HALF_TURN_STAIR + + +two_quarter_winding_stair = IfcStairTypeEnum.TWO_QUARTER_WINDING_STAIR + + +two_quarter_turn_stair = IfcStairTypeEnum.TWO_QUARTER_TURN_STAIR + + +three_quarter_winding_stair = IfcStairTypeEnum.THREE_QUARTER_WINDING_STAIR + + +three_quarter_turn_stair = IfcStairTypeEnum.THREE_QUARTER_TURN_STAIR + + +spiral_stair = IfcStairTypeEnum.SPIRAL_STAIR + + +double_return_stair = IfcStairTypeEnum.DOUBLE_RETURN_STAIR + + +curved_run_stair = IfcStairTypeEnum.CURVED_RUN_STAIR + + +two_curved_run_stair = IfcStairTypeEnum.TWO_CURVED_RUN_STAIR + + +userdefined = IfcStairTypeEnum.USERDEFINED + + +notdefined = IfcStairTypeEnum.NOTDEFINED + + +IfcStateEnum = enum_namespace() + + +readwrite = IfcStateEnum.READWRITE + + +readonly = IfcStateEnum.READONLY + + +locked = IfcStateEnum.LOCKED + + +readwritelocked = IfcStateEnum.READWRITELOCKED + + +readonlylocked = IfcStateEnum.READONLYLOCKED + + +IfcStructuralCurveActivityTypeEnum = enum_namespace() + + +const = IfcStructuralCurveActivityTypeEnum.CONST + + +linear = IfcStructuralCurveActivityTypeEnum.LINEAR + + +polygonal = IfcStructuralCurveActivityTypeEnum.POLYGONAL + + +equidistant = IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + +sinus = IfcStructuralCurveActivityTypeEnum.SINUS + + +parabola = IfcStructuralCurveActivityTypeEnum.PARABOLA + + +discrete = IfcStructuralCurveActivityTypeEnum.DISCRETE + + +userdefined = IfcStructuralCurveActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveActivityTypeEnum.NOTDEFINED + + +IfcStructuralCurveMemberTypeEnum = enum_namespace() + + +rigid_joined_member = IfcStructuralCurveMemberTypeEnum.RIGID_JOINED_MEMBER + + +pin_joined_member = IfcStructuralCurveMemberTypeEnum.PIN_JOINED_MEMBER + + +cable = IfcStructuralCurveMemberTypeEnum.CABLE + + +tension_member = IfcStructuralCurveMemberTypeEnum.TENSION_MEMBER + + +compression_member = IfcStructuralCurveMemberTypeEnum.COMPRESSION_MEMBER + + +userdefined = IfcStructuralCurveMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveMemberTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceActivityTypeEnum = enum_namespace() + + +const = IfcStructuralSurfaceActivityTypeEnum.CONST + + +bilinear = IfcStructuralSurfaceActivityTypeEnum.BILINEAR + + +discrete = IfcStructuralSurfaceActivityTypeEnum.DISCRETE + + +isocontour = IfcStructuralSurfaceActivityTypeEnum.ISOCONTOUR + + +userdefined = IfcStructuralSurfaceActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceActivityTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceMemberTypeEnum = enum_namespace() + + +bending_element = IfcStructuralSurfaceMemberTypeEnum.BENDING_ELEMENT + + +membrane_element = IfcStructuralSurfaceMemberTypeEnum.MEMBRANE_ELEMENT + + +shell = IfcStructuralSurfaceMemberTypeEnum.SHELL + + +userdefined = IfcStructuralSurfaceMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceMemberTypeEnum.NOTDEFINED + + +IfcSubContractResourceTypeEnum = enum_namespace() + + +purchase = IfcSubContractResourceTypeEnum.PURCHASE + + +work = IfcSubContractResourceTypeEnum.WORK + + +userdefined = IfcSubContractResourceTypeEnum.USERDEFINED + + +notdefined = IfcSubContractResourceTypeEnum.NOTDEFINED + + +IfcSurfaceFeatureTypeEnum = enum_namespace() + + +mark = IfcSurfaceFeatureTypeEnum.MARK + + +tag = IfcSurfaceFeatureTypeEnum.TAG + + +treatment = IfcSurfaceFeatureTypeEnum.TREATMENT + + +defect = IfcSurfaceFeatureTypeEnum.DEFECT + + +userdefined = IfcSurfaceFeatureTypeEnum.USERDEFINED + + +notdefined = IfcSurfaceFeatureTypeEnum.NOTDEFINED + + +IfcSurfaceSide = enum_namespace() + + +positive = IfcSurfaceSide.POSITIVE + + +negative = IfcSurfaceSide.NEGATIVE + + +both = IfcSurfaceSide.BOTH + + +IfcSwitchingDeviceTypeEnum = enum_namespace() + + +contactor = IfcSwitchingDeviceTypeEnum.CONTACTOR + + +dimmerswitch = IfcSwitchingDeviceTypeEnum.DIMMERSWITCH + + +emergencystop = IfcSwitchingDeviceTypeEnum.EMERGENCYSTOP + + +keypad = IfcSwitchingDeviceTypeEnum.KEYPAD + + +momentaryswitch = IfcSwitchingDeviceTypeEnum.MOMENTARYSWITCH + + +selectorswitch = IfcSwitchingDeviceTypeEnum.SELECTORSWITCH + + +starter = IfcSwitchingDeviceTypeEnum.STARTER + + +switchdisconnector = IfcSwitchingDeviceTypeEnum.SWITCHDISCONNECTOR + + +toggleswitch = IfcSwitchingDeviceTypeEnum.TOGGLESWITCH + + +userdefined = IfcSwitchingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSwitchingDeviceTypeEnum.NOTDEFINED + + +IfcSystemFurnitureElementTypeEnum = enum_namespace() + + +panel = IfcSystemFurnitureElementTypeEnum.PANEL + + +worksurface = IfcSystemFurnitureElementTypeEnum.WORKSURFACE + + +userdefined = IfcSystemFurnitureElementTypeEnum.USERDEFINED + + +notdefined = IfcSystemFurnitureElementTypeEnum.NOTDEFINED + + +IfcTankTypeEnum = enum_namespace() + + +basin = IfcTankTypeEnum.BASIN + + +breakpressure = IfcTankTypeEnum.BREAKPRESSURE + + +expansion = IfcTankTypeEnum.EXPANSION + + +feedandexpansion = IfcTankTypeEnum.FEEDANDEXPANSION + + +pressurevessel = IfcTankTypeEnum.PRESSUREVESSEL + + +storage = IfcTankTypeEnum.STORAGE + + +vessel = IfcTankTypeEnum.VESSEL + + +userdefined = IfcTankTypeEnum.USERDEFINED + + +notdefined = IfcTankTypeEnum.NOTDEFINED + + +IfcTaskDurationEnum = enum_namespace() + + +elapsedtime = IfcTaskDurationEnum.ELAPSEDTIME + + +worktime = IfcTaskDurationEnum.WORKTIME + + +notdefined = IfcTaskDurationEnum.NOTDEFINED + + +IfcTaskTypeEnum = enum_namespace() + + +attendance = IfcTaskTypeEnum.ATTENDANCE + + +construction = IfcTaskTypeEnum.CONSTRUCTION + + +demolition = IfcTaskTypeEnum.DEMOLITION + + +dismantle = IfcTaskTypeEnum.DISMANTLE + + +disposal = IfcTaskTypeEnum.DISPOSAL + + +installation = IfcTaskTypeEnum.INSTALLATION + + +logistic = IfcTaskTypeEnum.LOGISTIC + + +maintenance = IfcTaskTypeEnum.MAINTENANCE + + +move = IfcTaskTypeEnum.MOVE + + +operation = IfcTaskTypeEnum.OPERATION + + +removal = IfcTaskTypeEnum.REMOVAL + + +renovation = IfcTaskTypeEnum.RENOVATION + + +userdefined = IfcTaskTypeEnum.USERDEFINED + + +notdefined = IfcTaskTypeEnum.NOTDEFINED + + +IfcTendonAnchorTypeEnum = enum_namespace() + + +coupler = IfcTendonAnchorTypeEnum.COUPLER + + +fixed_end = IfcTendonAnchorTypeEnum.FIXED_END + + +tensioning_end = IfcTendonAnchorTypeEnum.TENSIONING_END + + +userdefined = IfcTendonAnchorTypeEnum.USERDEFINED + + +notdefined = IfcTendonAnchorTypeEnum.NOTDEFINED + + +IfcTendonConduitTypeEnum = enum_namespace() + + +duct = IfcTendonConduitTypeEnum.DUCT + + +coupler = IfcTendonConduitTypeEnum.COUPLER + + +grouting_duct = IfcTendonConduitTypeEnum.GROUTING_DUCT + + +trumpet = IfcTendonConduitTypeEnum.TRUMPET + + +diabolo = IfcTendonConduitTypeEnum.DIABOLO + + +userdefined = IfcTendonConduitTypeEnum.USERDEFINED + + +notdefined = IfcTendonConduitTypeEnum.NOTDEFINED + + +IfcTendonTypeEnum = enum_namespace() + + +bar = IfcTendonTypeEnum.BAR + + +coated = IfcTendonTypeEnum.COATED + + +strand = IfcTendonTypeEnum.STRAND + + +wire = IfcTendonTypeEnum.WIRE + + +userdefined = IfcTendonTypeEnum.USERDEFINED + + +notdefined = IfcTendonTypeEnum.NOTDEFINED + + +IfcTextPath = enum_namespace() + + +left = IfcTextPath.LEFT + + +right = IfcTextPath.RIGHT + + +up = IfcTextPath.UP + + +down = IfcTextPath.DOWN + + +IfcTimeSeriesDataTypeEnum = enum_namespace() + + +continuous = IfcTimeSeriesDataTypeEnum.CONTINUOUS + + +discrete = IfcTimeSeriesDataTypeEnum.DISCRETE + + +discretebinary = IfcTimeSeriesDataTypeEnum.DISCRETEBINARY + + +piecewisebinary = IfcTimeSeriesDataTypeEnum.PIECEWISEBINARY + + +piecewiseconstant = IfcTimeSeriesDataTypeEnum.PIECEWISECONSTANT + + +piecewisecontinuous = IfcTimeSeriesDataTypeEnum.PIECEWISECONTINUOUS + + +notdefined = IfcTimeSeriesDataTypeEnum.NOTDEFINED + + +IfcTransformerTypeEnum = enum_namespace() + + +current = IfcTransformerTypeEnum.CURRENT + + +frequency = IfcTransformerTypeEnum.FREQUENCY + + +inverter = IfcTransformerTypeEnum.INVERTER + + +rectifier = IfcTransformerTypeEnum.RECTIFIER + + +voltage = IfcTransformerTypeEnum.VOLTAGE + + +userdefined = IfcTransformerTypeEnum.USERDEFINED + + +notdefined = IfcTransformerTypeEnum.NOTDEFINED + + +IfcTransitionCode = enum_namespace() + + +discontinuous = IfcTransitionCode.DISCONTINUOUS + + +continuous = IfcTransitionCode.CONTINUOUS + + +contsamegradient = IfcTransitionCode.CONTSAMEGRADIENT + + +contsamegradientsamecurvature = IfcTransitionCode.CONTSAMEGRADIENTSAMECURVATURE + + +IfcTransitionCurveType = enum_namespace() + + +biquadraticparabola = IfcTransitionCurveType.BIQUADRATICPARABOLA + + +blosscurve = IfcTransitionCurveType.BLOSSCURVE + + +clothoidcurve = IfcTransitionCurveType.CLOTHOIDCURVE + + +cosinecurve = IfcTransitionCurveType.COSINECURVE + + +cubicparabola = IfcTransitionCurveType.CUBICPARABOLA + + +sinecurve = IfcTransitionCurveType.SINECURVE + + +IfcTransportElementTypeEnum = enum_namespace() + + +elevator = IfcTransportElementTypeEnum.ELEVATOR + + +escalator = IfcTransportElementTypeEnum.ESCALATOR + + +movingwalkway = IfcTransportElementTypeEnum.MOVINGWALKWAY + + +craneway = IfcTransportElementTypeEnum.CRANEWAY + + +liftinggear = IfcTransportElementTypeEnum.LIFTINGGEAR + + +userdefined = IfcTransportElementTypeEnum.USERDEFINED + + +notdefined = IfcTransportElementTypeEnum.NOTDEFINED + + +IfcTrimmingPreference = enum_namespace() + + +cartesian = IfcTrimmingPreference.CARTESIAN + + +parameter = IfcTrimmingPreference.PARAMETER + + +unspecified = IfcTrimmingPreference.UNSPECIFIED + + +IfcTubeBundleTypeEnum = enum_namespace() + + +finned = IfcTubeBundleTypeEnum.FINNED + + +userdefined = IfcTubeBundleTypeEnum.USERDEFINED + + +notdefined = IfcTubeBundleTypeEnum.NOTDEFINED + + +IfcUnitEnum = enum_namespace() + + +absorbeddoseunit = IfcUnitEnum.ABSORBEDDOSEUNIT + + +amountofsubstanceunit = IfcUnitEnum.AMOUNTOFSUBSTANCEUNIT + + +areaunit = IfcUnitEnum.AREAUNIT + + +doseequivalentunit = IfcUnitEnum.DOSEEQUIVALENTUNIT + + +electriccapacitanceunit = IfcUnitEnum.ELECTRICCAPACITANCEUNIT + + +electricchargeunit = IfcUnitEnum.ELECTRICCHARGEUNIT + + +electricconductanceunit = IfcUnitEnum.ELECTRICCONDUCTANCEUNIT + + +electriccurrentunit = IfcUnitEnum.ELECTRICCURRENTUNIT + + +electricresistanceunit = IfcUnitEnum.ELECTRICRESISTANCEUNIT + + +electricvoltageunit = IfcUnitEnum.ELECTRICVOLTAGEUNIT + + +energyunit = IfcUnitEnum.ENERGYUNIT + + +forceunit = IfcUnitEnum.FORCEUNIT + + +frequencyunit = IfcUnitEnum.FREQUENCYUNIT + + +illuminanceunit = IfcUnitEnum.ILLUMINANCEUNIT + + +inductanceunit = IfcUnitEnum.INDUCTANCEUNIT + + +lengthunit = IfcUnitEnum.LENGTHUNIT + + +luminousfluxunit = IfcUnitEnum.LUMINOUSFLUXUNIT + + +luminousintensityunit = IfcUnitEnum.LUMINOUSINTENSITYUNIT + + +magneticfluxdensityunit = IfcUnitEnum.MAGNETICFLUXDENSITYUNIT + + +magneticfluxunit = IfcUnitEnum.MAGNETICFLUXUNIT + + +massunit = IfcUnitEnum.MASSUNIT + + +planeangleunit = IfcUnitEnum.PLANEANGLEUNIT + + +powerunit = IfcUnitEnum.POWERUNIT + + +pressureunit = IfcUnitEnum.PRESSUREUNIT + + +radioactivityunit = IfcUnitEnum.RADIOACTIVITYUNIT + + +solidangleunit = IfcUnitEnum.SOLIDANGLEUNIT + + +thermodynamictemperatureunit = IfcUnitEnum.THERMODYNAMICTEMPERATUREUNIT + + +timeunit = IfcUnitEnum.TIMEUNIT + + +volumeunit = IfcUnitEnum.VOLUMEUNIT + + +userdefined = IfcUnitEnum.USERDEFINED + + +IfcUnitaryControlElementTypeEnum = enum_namespace() + + +alarmpanel = IfcUnitaryControlElementTypeEnum.ALARMPANEL + + +controlpanel = IfcUnitaryControlElementTypeEnum.CONTROLPANEL + + +gasdetectionpanel = IfcUnitaryControlElementTypeEnum.GASDETECTIONPANEL + + +indicatorpanel = IfcUnitaryControlElementTypeEnum.INDICATORPANEL + + +mimicpanel = IfcUnitaryControlElementTypeEnum.MIMICPANEL + + +humidistat = IfcUnitaryControlElementTypeEnum.HUMIDISTAT + + +thermostat = IfcUnitaryControlElementTypeEnum.THERMOSTAT + + +weatherstation = IfcUnitaryControlElementTypeEnum.WEATHERSTATION + + +userdefined = IfcUnitaryControlElementTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryControlElementTypeEnum.NOTDEFINED + + +IfcUnitaryEquipmentTypeEnum = enum_namespace() + + +airhandler = IfcUnitaryEquipmentTypeEnum.AIRHANDLER + + +airconditioningunit = IfcUnitaryEquipmentTypeEnum.AIRCONDITIONINGUNIT + + +dehumidifier = IfcUnitaryEquipmentTypeEnum.DEHUMIDIFIER + + +splitsystem = IfcUnitaryEquipmentTypeEnum.SPLITSYSTEM + + +rooftopunit = IfcUnitaryEquipmentTypeEnum.ROOFTOPUNIT + + +userdefined = IfcUnitaryEquipmentTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryEquipmentTypeEnum.NOTDEFINED + + +IfcValveTypeEnum = enum_namespace() + + +airrelease = IfcValveTypeEnum.AIRRELEASE + + +antivacuum = IfcValveTypeEnum.ANTIVACUUM + + +changeover = IfcValveTypeEnum.CHANGEOVER + + +check = IfcValveTypeEnum.CHECK + + +commissioning = IfcValveTypeEnum.COMMISSIONING + + +diverting = IfcValveTypeEnum.DIVERTING + + +drawoffcock = IfcValveTypeEnum.DRAWOFFCOCK + + +doublecheck = IfcValveTypeEnum.DOUBLECHECK + + +doubleregulating = IfcValveTypeEnum.DOUBLEREGULATING + + +faucet = IfcValveTypeEnum.FAUCET + + +flushing = IfcValveTypeEnum.FLUSHING + + +gascock = IfcValveTypeEnum.GASCOCK + + +gastap = IfcValveTypeEnum.GASTAP + + +isolating = IfcValveTypeEnum.ISOLATING + + +mixing = IfcValveTypeEnum.MIXING + + +pressurereducing = IfcValveTypeEnum.PRESSUREREDUCING + + +pressurerelief = IfcValveTypeEnum.PRESSURERELIEF + + +regulating = IfcValveTypeEnum.REGULATING + + +safetycutoff = IfcValveTypeEnum.SAFETYCUTOFF + + +steamtrap = IfcValveTypeEnum.STEAMTRAP + + +stopcock = IfcValveTypeEnum.STOPCOCK + + +userdefined = IfcValveTypeEnum.USERDEFINED + + +notdefined = IfcValveTypeEnum.NOTDEFINED + + +IfcVibrationDamperTypeEnum = enum_namespace() + + +bending_yield = IfcVibrationDamperTypeEnum.BENDING_YIELD + + +shear_yield = IfcVibrationDamperTypeEnum.SHEAR_YIELD + + +axial_yield = IfcVibrationDamperTypeEnum.AXIAL_YIELD + + +friction = IfcVibrationDamperTypeEnum.FRICTION + + +viscous = IfcVibrationDamperTypeEnum.VISCOUS + + +rubber = IfcVibrationDamperTypeEnum.RUBBER + + +userdefined = IfcVibrationDamperTypeEnum.USERDEFINED + + +notdefined = IfcVibrationDamperTypeEnum.NOTDEFINED + + +IfcVibrationIsolatorTypeEnum = enum_namespace() + + +compression = IfcVibrationIsolatorTypeEnum.COMPRESSION + + +spring = IfcVibrationIsolatorTypeEnum.SPRING + + +base = IfcVibrationIsolatorTypeEnum.BASE + + +userdefined = IfcVibrationIsolatorTypeEnum.USERDEFINED + + +notdefined = IfcVibrationIsolatorTypeEnum.NOTDEFINED + + +IfcVoidingFeatureTypeEnum = enum_namespace() + + +cutout = IfcVoidingFeatureTypeEnum.CUTOUT + + +notch = IfcVoidingFeatureTypeEnum.NOTCH + + +hole = IfcVoidingFeatureTypeEnum.HOLE + + +miter = IfcVoidingFeatureTypeEnum.MITER + + +chamfer = IfcVoidingFeatureTypeEnum.CHAMFER + + +edge = IfcVoidingFeatureTypeEnum.EDGE + + +userdefined = IfcVoidingFeatureTypeEnum.USERDEFINED + + +notdefined = IfcVoidingFeatureTypeEnum.NOTDEFINED + + +IfcWallTypeEnum = enum_namespace() + + +movable = IfcWallTypeEnum.MOVABLE + + +parapet = IfcWallTypeEnum.PARAPET + + +partitioning = IfcWallTypeEnum.PARTITIONING + + +plumbingwall = IfcWallTypeEnum.PLUMBINGWALL + + +shear = IfcWallTypeEnum.SHEAR + + +solidwall = IfcWallTypeEnum.SOLIDWALL + + +standard = IfcWallTypeEnum.STANDARD + + +polygonal = IfcWallTypeEnum.POLYGONAL + + +elementedwall = IfcWallTypeEnum.ELEMENTEDWALL + + +retainingwall = IfcWallTypeEnum.RETAININGWALL + + +userdefined = IfcWallTypeEnum.USERDEFINED + + +notdefined = IfcWallTypeEnum.NOTDEFINED + + +IfcWasteTerminalTypeEnum = enum_namespace() + + +floortrap = IfcWasteTerminalTypeEnum.FLOORTRAP + + +floorwaste = IfcWasteTerminalTypeEnum.FLOORWASTE + + +gullysump = IfcWasteTerminalTypeEnum.GULLYSUMP + + +gullytrap = IfcWasteTerminalTypeEnum.GULLYTRAP + + +roofdrain = IfcWasteTerminalTypeEnum.ROOFDRAIN + + +wastedisposalunit = IfcWasteTerminalTypeEnum.WASTEDISPOSALUNIT + + +wastetrap = IfcWasteTerminalTypeEnum.WASTETRAP + + +userdefined = IfcWasteTerminalTypeEnum.USERDEFINED + + +notdefined = IfcWasteTerminalTypeEnum.NOTDEFINED + + +IfcWindowPanelOperationEnum = enum_namespace() + + +sidehungrighthand = IfcWindowPanelOperationEnum.SIDEHUNGRIGHTHAND + + +sidehunglefthand = IfcWindowPanelOperationEnum.SIDEHUNGLEFTHAND + + +tiltandturnrighthand = IfcWindowPanelOperationEnum.TILTANDTURNRIGHTHAND + + +tiltandturnlefthand = IfcWindowPanelOperationEnum.TILTANDTURNLEFTHAND + + +tophung = IfcWindowPanelOperationEnum.TOPHUNG + + +bottomhung = IfcWindowPanelOperationEnum.BOTTOMHUNG + + +pivothorizontal = IfcWindowPanelOperationEnum.PIVOTHORIZONTAL + + +pivotvertical = IfcWindowPanelOperationEnum.PIVOTVERTICAL + + +slidinghorizontal = IfcWindowPanelOperationEnum.SLIDINGHORIZONTAL + + +slidingvertical = IfcWindowPanelOperationEnum.SLIDINGVERTICAL + + +removablecasement = IfcWindowPanelOperationEnum.REMOVABLECASEMENT + + +fixedcasement = IfcWindowPanelOperationEnum.FIXEDCASEMENT + + +otheroperation = IfcWindowPanelOperationEnum.OTHEROPERATION + + +notdefined = IfcWindowPanelOperationEnum.NOTDEFINED + + +IfcWindowPanelPositionEnum = enum_namespace() + + +left = IfcWindowPanelPositionEnum.LEFT + + +middle = IfcWindowPanelPositionEnum.MIDDLE + + +right = IfcWindowPanelPositionEnum.RIGHT + + +bottom = IfcWindowPanelPositionEnum.BOTTOM + + +top = IfcWindowPanelPositionEnum.TOP + + +notdefined = IfcWindowPanelPositionEnum.NOTDEFINED + + +IfcWindowStyleConstructionEnum = enum_namespace() + + +aluminium = IfcWindowStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcWindowStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcWindowStyleConstructionEnum.STEEL + + +wood = IfcWindowStyleConstructionEnum.WOOD + + +aluminium_wood = IfcWindowStyleConstructionEnum.ALUMINIUM_WOOD + + +plastic = IfcWindowStyleConstructionEnum.PLASTIC + + +other_construction = IfcWindowStyleConstructionEnum.OTHER_CONSTRUCTION + + +notdefined = IfcWindowStyleConstructionEnum.NOTDEFINED + + +IfcWindowStyleOperationEnum = enum_namespace() + + +single_panel = IfcWindowStyleOperationEnum.SINGLE_PANEL + + +double_panel_vertical = IfcWindowStyleOperationEnum.DOUBLE_PANEL_VERTICAL + + +double_panel_horizontal = IfcWindowStyleOperationEnum.DOUBLE_PANEL_HORIZONTAL + + +triple_panel_vertical = IfcWindowStyleOperationEnum.TRIPLE_PANEL_VERTICAL + + +triple_panel_bottom = IfcWindowStyleOperationEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_top = IfcWindowStyleOperationEnum.TRIPLE_PANEL_TOP + + +triple_panel_left = IfcWindowStyleOperationEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowStyleOperationEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_horizontal = IfcWindowStyleOperationEnum.TRIPLE_PANEL_HORIZONTAL + + +userdefined = IfcWindowStyleOperationEnum.USERDEFINED + + +notdefined = IfcWindowStyleOperationEnum.NOTDEFINED + + +IfcWindowTypeEnum = enum_namespace() + + +window = IfcWindowTypeEnum.WINDOW + + +skylight = IfcWindowTypeEnum.SKYLIGHT + + +lightdome = IfcWindowTypeEnum.LIGHTDOME + + +userdefined = IfcWindowTypeEnum.USERDEFINED + + +notdefined = IfcWindowTypeEnum.NOTDEFINED + + +IfcWindowTypePartitioningEnum = enum_namespace() + + +single_panel = IfcWindowTypePartitioningEnum.SINGLE_PANEL + + +double_panel_vertical = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_VERTICAL + + +double_panel_horizontal = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_HORIZONTAL + + +triple_panel_vertical = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_VERTICAL + + +triple_panel_bottom = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_top = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_TOP + + +triple_panel_left = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_horizontal = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_HORIZONTAL + + +userdefined = IfcWindowTypePartitioningEnum.USERDEFINED + + +notdefined = IfcWindowTypePartitioningEnum.NOTDEFINED + + +IfcWorkCalendarTypeEnum = enum_namespace() + + +firstshift = IfcWorkCalendarTypeEnum.FIRSTSHIFT + + +secondshift = IfcWorkCalendarTypeEnum.SECONDSHIFT + + +thirdshift = IfcWorkCalendarTypeEnum.THIRDSHIFT + + +userdefined = IfcWorkCalendarTypeEnum.USERDEFINED + + +notdefined = IfcWorkCalendarTypeEnum.NOTDEFINED + + +IfcWorkPlanTypeEnum = enum_namespace() + + +actual = IfcWorkPlanTypeEnum.ACTUAL + + +baseline = IfcWorkPlanTypeEnum.BASELINE + + +planned = IfcWorkPlanTypeEnum.PLANNED + + +userdefined = IfcWorkPlanTypeEnum.USERDEFINED + + +notdefined = IfcWorkPlanTypeEnum.NOTDEFINED + + +IfcWorkScheduleTypeEnum = enum_namespace() + + +actual = IfcWorkScheduleTypeEnum.ACTUAL + + +baseline = IfcWorkScheduleTypeEnum.BASELINE + + +planned = IfcWorkScheduleTypeEnum.PLANNED + + +userdefined = IfcWorkScheduleTypeEnum.USERDEFINED + + +notdefined = IfcWorkScheduleTypeEnum.NOTDEFINED + + +def IfcActionRequest(*args, **kwargs): return ifcopenshell.create_entity('IfcActionRequest', 'IFC4X2', *args, **kwargs) + + +def IfcActor(*args, **kwargs): return ifcopenshell.create_entity('IfcActor', 'IFC4X2', *args, **kwargs) + + +def IfcActorRole(*args, **kwargs): return ifcopenshell.create_entity('IfcActorRole', 'IFC4X2', *args, **kwargs) + + +def IfcActuator(*args, **kwargs): return ifcopenshell.create_entity('IfcActuator', 'IFC4X2', *args, **kwargs) + + +def IfcActuatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcActuatorType', 'IFC4X2', *args, **kwargs) + + +def IfcAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcAddress', 'IFC4X2', *args, **kwargs) + + +def IfcAdvancedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrep', 'IFC4X2', *args, **kwargs) + + +def IfcAdvancedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrepWithVoids', 'IFC4X2', *args, **kwargs) + + +def IfcAdvancedFace(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedFace', 'IFC4X2', *args, **kwargs) + + +def IfcAirTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminal', 'IFC4X2', *args, **kwargs) + + +def IfcAirTerminalBox(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBox', 'IFC4X2', *args, **kwargs) + + +def IfcAirTerminalBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBoxType', 'IFC4X2', *args, **kwargs) + + +def IfcAirTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalType', 'IFC4X2', *args, **kwargs) + + +def IfcAirToAirHeatRecovery(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecovery', 'IFC4X2', *args, **kwargs) + + +def IfcAirToAirHeatRecoveryType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecoveryType', 'IFC4X2', *args, **kwargs) + + +def IfcAlarm(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarm', 'IFC4X2', *args, **kwargs) + + +def IfcAlarmType(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarmType', 'IFC4X2', *args, **kwargs) + + +def IfcAlignment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment', 'IFC4X2', *args, **kwargs) + + +def IfcAlignment2DHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DHorizontal', 'IFC4X2', *args, **kwargs) + + +def IfcAlignment2DHorizontalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DHorizontalSegment', 'IFC4X2', *args, **kwargs) + + +def IfcAlignment2DSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DSegment', 'IFC4X2', *args, **kwargs) + + +def IfcAlignment2DVerSegCircularArc(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerSegCircularArc', 'IFC4X2', *args, **kwargs) + + +def IfcAlignment2DVerSegLine(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerSegLine', 'IFC4X2', *args, **kwargs) + + +def IfcAlignment2DVerSegParabolicArc(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerSegParabolicArc', 'IFC4X2', *args, **kwargs) + + +def IfcAlignment2DVertical(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVertical', 'IFC4X2', *args, **kwargs) + + +def IfcAlignment2DVerticalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerticalSegment', 'IFC4X2', *args, **kwargs) + + +def IfcAlignmentCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCurve', 'IFC4X2', *args, **kwargs) + + +def IfcAnnotation(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotation', 'IFC4X2', *args, **kwargs) + + +def IfcAnnotationFillArea(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationFillArea', 'IFC4X2', *args, **kwargs) + + +def IfcApplication(*args, **kwargs): return ifcopenshell.create_entity('IfcApplication', 'IFC4X2', *args, **kwargs) + + +def IfcAppliedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcAppliedValue', 'IFC4X2', *args, **kwargs) + + +def IfcApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcApproval', 'IFC4X2', *args, **kwargs) + + +def IfcApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcApprovalRelationship', 'IFC4X2', *args, **kwargs) + + +def IfcArbitraryClosedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryClosedProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcArbitraryOpenProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryOpenProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcArbitraryProfileDefWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryProfileDefWithVoids', 'IFC4X2', *args, **kwargs) + + +def IfcAsset(*args, **kwargs): return ifcopenshell.create_entity('IfcAsset', 'IFC4X2', *args, **kwargs) + + +def IfcAsymmetricIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcAsymmetricIShapeProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcAudioVisualAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualAppliance', 'IFC4X2', *args, **kwargs) + + +def IfcAudioVisualApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualApplianceType', 'IFC4X2', *args, **kwargs) + + +def IfcAxis1Placement(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis1Placement', 'IFC4X2', *args, **kwargs) + + +def IfcAxis2Placement2D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement2D', 'IFC4X2', *args, **kwargs) + + +def IfcAxis2Placement3D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement3D', 'IFC4X2', *args, **kwargs) + + +def IfcBSplineCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurve', 'IFC4X2', *args, **kwargs) + + +def IfcBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurveWithKnots', 'IFC4X2', *args, **kwargs) + + +def IfcBSplineSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurface', 'IFC4X2', *args, **kwargs) + + +def IfcBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurfaceWithKnots', 'IFC4X2', *args, **kwargs) + + +def IfcBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcBeam', 'IFC4X2', *args, **kwargs) + + +def IfcBeamStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamStandardCase', 'IFC4X2', *args, **kwargs) + + +def IfcBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamType', 'IFC4X2', *args, **kwargs) + + +def IfcBearing(*args, **kwargs): return ifcopenshell.create_entity('IfcBearing', 'IFC4X2', *args, **kwargs) + + +def IfcBearingType(*args, **kwargs): return ifcopenshell.create_entity('IfcBearingType', 'IFC4X2', *args, **kwargs) + + +def IfcBlobTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcBlobTexture', 'IFC4X2', *args, **kwargs) + + +def IfcBlock(*args, **kwargs): return ifcopenshell.create_entity('IfcBlock', 'IFC4X2', *args, **kwargs) + + +def IfcBoiler(*args, **kwargs): return ifcopenshell.create_entity('IfcBoiler', 'IFC4X2', *args, **kwargs) + + +def IfcBoilerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBoilerType', 'IFC4X2', *args, **kwargs) + + +def IfcBooleanClippingResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanClippingResult', 'IFC4X2', *args, **kwargs) + + +def IfcBooleanResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanResult', 'IFC4X2', *args, **kwargs) + + +def IfcBoundaryCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCondition', 'IFC4X2', *args, **kwargs) + + +def IfcBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCurve', 'IFC4X2', *args, **kwargs) + + +def IfcBoundaryEdgeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryEdgeCondition', 'IFC4X2', *args, **kwargs) + + +def IfcBoundaryFaceCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryFaceCondition', 'IFC4X2', *args, **kwargs) + + +def IfcBoundaryNodeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeCondition', 'IFC4X2', *args, **kwargs) + + +def IfcBoundaryNodeConditionWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeConditionWarping', 'IFC4X2', *args, **kwargs) + + +def IfcBoundedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedCurve', 'IFC4X2', *args, **kwargs) + + +def IfcBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedSurface', 'IFC4X2', *args, **kwargs) + + +def IfcBoundingBox(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundingBox', 'IFC4X2', *args, **kwargs) + + +def IfcBoxedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcBoxedHalfSpace', 'IFC4X2', *args, **kwargs) + + +def IfcBridge(*args, **kwargs): return ifcopenshell.create_entity('IfcBridge', 'IFC4X2', *args, **kwargs) + + +def IfcBridgePart(*args, **kwargs): return ifcopenshell.create_entity('IfcBridgePart', 'IFC4X2', *args, **kwargs) + + +def IfcBuilding(*args, **kwargs): return ifcopenshell.create_entity('IfcBuilding', 'IFC4X2', *args, **kwargs) + + +def IfcBuildingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElement', 'IFC4X2', *args, **kwargs) + + +def IfcBuildingElementPart(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPart', 'IFC4X2', *args, **kwargs) + + +def IfcBuildingElementPartType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPartType', 'IFC4X2', *args, **kwargs) + + +def IfcBuildingElementProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxy', 'IFC4X2', *args, **kwargs) + + +def IfcBuildingElementProxyType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxyType', 'IFC4X2', *args, **kwargs) + + +def IfcBuildingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementType', 'IFC4X2', *args, **kwargs) + + +def IfcBuildingStorey(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingStorey', 'IFC4X2', *args, **kwargs) + + +def IfcBuildingSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingSystem', 'IFC4X2', *args, **kwargs) + + +def IfcBurner(*args, **kwargs): return ifcopenshell.create_entity('IfcBurner', 'IFC4X2', *args, **kwargs) + + +def IfcBurnerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBurnerType', 'IFC4X2', *args, **kwargs) + + +def IfcCShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCShapeProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcCableCarrierFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFitting', 'IFC4X2', *args, **kwargs) + + +def IfcCableCarrierFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFittingType', 'IFC4X2', *args, **kwargs) + + +def IfcCableCarrierSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegment', 'IFC4X2', *args, **kwargs) + + +def IfcCableCarrierSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegmentType', 'IFC4X2', *args, **kwargs) + + +def IfcCableFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFitting', 'IFC4X2', *args, **kwargs) + + +def IfcCableFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFittingType', 'IFC4X2', *args, **kwargs) + + +def IfcCableSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegment', 'IFC4X2', *args, **kwargs) + + +def IfcCableSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegmentType', 'IFC4X2', *args, **kwargs) + + +def IfcCaissonFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundation', 'IFC4X2', *args, **kwargs) + + +def IfcCaissonFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundationType', 'IFC4X2', *args, **kwargs) + + +def IfcCartesianPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPoint', 'IFC4X2', *args, **kwargs) + + +def IfcCartesianPointList(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList', 'IFC4X2', *args, **kwargs) + + +def IfcCartesianPointList2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList2D', 'IFC4X2', *args, **kwargs) + + +def IfcCartesianPointList3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList3D', 'IFC4X2', *args, **kwargs) + + +def IfcCartesianTransformationOperator(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator', 'IFC4X2', *args, **kwargs) + + +def IfcCartesianTransformationOperator2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2D', 'IFC4X2', *args, **kwargs) + + +def IfcCartesianTransformationOperator2DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2DnonUniform', 'IFC4X2', *args, **kwargs) + + +def IfcCartesianTransformationOperator3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3D', 'IFC4X2', *args, **kwargs) + + +def IfcCartesianTransformationOperator3DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3DnonUniform', 'IFC4X2', *args, **kwargs) + + +def IfcCenterLineProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCenterLineProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcChiller(*args, **kwargs): return ifcopenshell.create_entity('IfcChiller', 'IFC4X2', *args, **kwargs) + + +def IfcChillerType(*args, **kwargs): return ifcopenshell.create_entity('IfcChillerType', 'IFC4X2', *args, **kwargs) + + +def IfcChimney(*args, **kwargs): return ifcopenshell.create_entity('IfcChimney', 'IFC4X2', *args, **kwargs) + + +def IfcChimneyType(*args, **kwargs): return ifcopenshell.create_entity('IfcChimneyType', 'IFC4X2', *args, **kwargs) + + +def IfcCircle(*args, **kwargs): return ifcopenshell.create_entity('IfcCircle', 'IFC4X2', *args, **kwargs) + + +def IfcCircleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleHollowProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcCircleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcCircularArcSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCircularArcSegment2D', 'IFC4X2', *args, **kwargs) + + +def IfcCivilElement(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElement', 'IFC4X2', *args, **kwargs) + + +def IfcCivilElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElementType', 'IFC4X2', *args, **kwargs) + + +def IfcClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcClassification', 'IFC4X2', *args, **kwargs) + + +def IfcClassificationReference(*args, **kwargs): return ifcopenshell.create_entity('IfcClassificationReference', 'IFC4X2', *args, **kwargs) + + +def IfcClosedShell(*args, **kwargs): return ifcopenshell.create_entity('IfcClosedShell', 'IFC4X2', *args, **kwargs) + + +def IfcCoil(*args, **kwargs): return ifcopenshell.create_entity('IfcCoil', 'IFC4X2', *args, **kwargs) + + +def IfcCoilType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoilType', 'IFC4X2', *args, **kwargs) + + +def IfcColourRgb(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgb', 'IFC4X2', *args, **kwargs) + + +def IfcColourRgbList(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgbList', 'IFC4X2', *args, **kwargs) + + +def IfcColourSpecification(*args, **kwargs): return ifcopenshell.create_entity('IfcColourSpecification', 'IFC4X2', *args, **kwargs) + + +def IfcColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcColumn', 'IFC4X2', *args, **kwargs) + + +def IfcColumnStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnStandardCase', 'IFC4X2', *args, **kwargs) + + +def IfcColumnType(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnType', 'IFC4X2', *args, **kwargs) + + +def IfcCommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsAppliance', 'IFC4X2', *args, **kwargs) + + +def IfcCommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsApplianceType', 'IFC4X2', *args, **kwargs) + + +def IfcComplexProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexProperty', 'IFC4X2', *args, **kwargs) + + +def IfcComplexPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexPropertyTemplate', 'IFC4X2', *args, **kwargs) + + +def IfcCompositeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurve', 'IFC4X2', *args, **kwargs) + + +def IfcCompositeCurveOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveOnSurface', 'IFC4X2', *args, **kwargs) + + +def IfcCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveSegment', 'IFC4X2', *args, **kwargs) + + +def IfcCompositeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcCompressor(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressor', 'IFC4X2', *args, **kwargs) + + +def IfcCompressorType(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressorType', 'IFC4X2', *args, **kwargs) + + +def IfcCondenser(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenser', 'IFC4X2', *args, **kwargs) + + +def IfcCondenserType(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenserType', 'IFC4X2', *args, **kwargs) + + +def IfcConic(*args, **kwargs): return ifcopenshell.create_entity('IfcConic', 'IFC4X2', *args, **kwargs) + + +def IfcConnectedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectedFaceSet', 'IFC4X2', *args, **kwargs) + + +def IfcConnectionCurveGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionCurveGeometry', 'IFC4X2', *args, **kwargs) + + +def IfcConnectionGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionGeometry', 'IFC4X2', *args, **kwargs) + + +def IfcConnectionPointEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointEccentricity', 'IFC4X2', *args, **kwargs) + + +def IfcConnectionPointGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointGeometry', 'IFC4X2', *args, **kwargs) + + +def IfcConnectionSurfaceGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionSurfaceGeometry', 'IFC4X2', *args, **kwargs) + + +def IfcConnectionVolumeGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionVolumeGeometry', 'IFC4X2', *args, **kwargs) + + +def IfcConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcConstraint', 'IFC4X2', *args, **kwargs) + + +def IfcConstructionEquipmentResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResource', 'IFC4X2', *args, **kwargs) + + +def IfcConstructionEquipmentResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResourceType', 'IFC4X2', *args, **kwargs) + + +def IfcConstructionMaterialResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResource', 'IFC4X2', *args, **kwargs) + + +def IfcConstructionMaterialResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResourceType', 'IFC4X2', *args, **kwargs) + + +def IfcConstructionProductResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResource', 'IFC4X2', *args, **kwargs) + + +def IfcConstructionProductResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResourceType', 'IFC4X2', *args, **kwargs) + + +def IfcConstructionResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResource', 'IFC4X2', *args, **kwargs) + + +def IfcConstructionResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResourceType', 'IFC4X2', *args, **kwargs) + + +def IfcContext(*args, **kwargs): return ifcopenshell.create_entity('IfcContext', 'IFC4X2', *args, **kwargs) + + +def IfcContextDependentUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcContextDependentUnit', 'IFC4X2', *args, **kwargs) + + +def IfcControl(*args, **kwargs): return ifcopenshell.create_entity('IfcControl', 'IFC4X2', *args, **kwargs) + + +def IfcController(*args, **kwargs): return ifcopenshell.create_entity('IfcController', 'IFC4X2', *args, **kwargs) + + +def IfcControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcControllerType', 'IFC4X2', *args, **kwargs) + + +def IfcConversionBasedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnit', 'IFC4X2', *args, **kwargs) + + +def IfcConversionBasedUnitWithOffset(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnitWithOffset', 'IFC4X2', *args, **kwargs) + + +def IfcCooledBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeam', 'IFC4X2', *args, **kwargs) + + +def IfcCooledBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeamType', 'IFC4X2', *args, **kwargs) + + +def IfcCoolingTower(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTower', 'IFC4X2', *args, **kwargs) + + +def IfcCoolingTowerType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTowerType', 'IFC4X2', *args, **kwargs) + + +def IfcCoordinateOperation(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateOperation', 'IFC4X2', *args, **kwargs) + + +def IfcCoordinateReferenceSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateReferenceSystem', 'IFC4X2', *args, **kwargs) + + +def IfcCostItem(*args, **kwargs): return ifcopenshell.create_entity('IfcCostItem', 'IFC4X2', *args, **kwargs) + + +def IfcCostSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcCostSchedule', 'IFC4X2', *args, **kwargs) + + +def IfcCostValue(*args, **kwargs): return ifcopenshell.create_entity('IfcCostValue', 'IFC4X2', *args, **kwargs) + + +def IfcCovering(*args, **kwargs): return ifcopenshell.create_entity('IfcCovering', 'IFC4X2', *args, **kwargs) + + +def IfcCoveringType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoveringType', 'IFC4X2', *args, **kwargs) + + +def IfcCrewResource(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResource', 'IFC4X2', *args, **kwargs) + + +def IfcCrewResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResourceType', 'IFC4X2', *args, **kwargs) + + +def IfcCsgPrimitive3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgPrimitive3D', 'IFC4X2', *args, **kwargs) + + +def IfcCsgSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgSolid', 'IFC4X2', *args, **kwargs) + + +def IfcCurrencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcCurrencyRelationship', 'IFC4X2', *args, **kwargs) + + +def IfcCurtainWall(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWall', 'IFC4X2', *args, **kwargs) + + +def IfcCurtainWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWallType', 'IFC4X2', *args, **kwargs) + + +def IfcCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCurve', 'IFC4X2', *args, **kwargs) + + +def IfcCurveBoundedPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedPlane', 'IFC4X2', *args, **kwargs) + + +def IfcCurveBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedSurface', 'IFC4X2', *args, **kwargs) + + +def IfcCurveSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveSegment2D', 'IFC4X2', *args, **kwargs) + + +def IfcCurveStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyle', 'IFC4X2', *args, **kwargs) + + +def IfcCurveStyleFont(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFont', 'IFC4X2', *args, **kwargs) + + +def IfcCurveStyleFontAndScaling(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontAndScaling', 'IFC4X2', *args, **kwargs) + + +def IfcCurveStyleFontPattern(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontPattern', 'IFC4X2', *args, **kwargs) + + +def IfcCylindricalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCylindricalSurface', 'IFC4X2', *args, **kwargs) + + +def IfcDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcDamper', 'IFC4X2', *args, **kwargs) + + +def IfcDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcDamperType', 'IFC4X2', *args, **kwargs) + + +def IfcDeepFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundation', 'IFC4X2', *args, **kwargs) + + +def IfcDeepFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundationType', 'IFC4X2', *args, **kwargs) + + +def IfcDerivedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcDerivedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnit', 'IFC4X2', *args, **kwargs) + + +def IfcDerivedUnitElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnitElement', 'IFC4X2', *args, **kwargs) + + +def IfcDimensionalExponents(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionalExponents', 'IFC4X2', *args, **kwargs) + + +def IfcDirection(*args, **kwargs): return ifcopenshell.create_entity('IfcDirection', 'IFC4X2', *args, **kwargs) + + +def IfcDiscreteAccessory(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessory', 'IFC4X2', *args, **kwargs) + + +def IfcDiscreteAccessoryType(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessoryType', 'IFC4X2', *args, **kwargs) + + +def IfcDistanceExpression(*args, **kwargs): return ifcopenshell.create_entity('IfcDistanceExpression', 'IFC4X2', *args, **kwargs) + + +def IfcDistributionChamberElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElement', 'IFC4X2', *args, **kwargs) + + +def IfcDistributionChamberElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElementType', 'IFC4X2', *args, **kwargs) + + +def IfcDistributionCircuit(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionCircuit', 'IFC4X2', *args, **kwargs) + + +def IfcDistributionControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElement', 'IFC4X2', *args, **kwargs) + + +def IfcDistributionControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElementType', 'IFC4X2', *args, **kwargs) + + +def IfcDistributionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElement', 'IFC4X2', *args, **kwargs) + + +def IfcDistributionElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElementType', 'IFC4X2', *args, **kwargs) + + +def IfcDistributionFlowElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElement', 'IFC4X2', *args, **kwargs) + + +def IfcDistributionFlowElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElementType', 'IFC4X2', *args, **kwargs) + + +def IfcDistributionPort(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionPort', 'IFC4X2', *args, **kwargs) + + +def IfcDistributionSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionSystem', 'IFC4X2', *args, **kwargs) + + +def IfcDocumentInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformation', 'IFC4X2', *args, **kwargs) + + +def IfcDocumentInformationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformationRelationship', 'IFC4X2', *args, **kwargs) + + +def IfcDocumentReference(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentReference', 'IFC4X2', *args, **kwargs) + + +def IfcDoor(*args, **kwargs): return ifcopenshell.create_entity('IfcDoor', 'IFC4X2', *args, **kwargs) + + +def IfcDoorLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorLiningProperties', 'IFC4X2', *args, **kwargs) + + +def IfcDoorPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorPanelProperties', 'IFC4X2', *args, **kwargs) + + +def IfcDoorStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorStandardCase', 'IFC4X2', *args, **kwargs) + + +def IfcDoorStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorStyle', 'IFC4X2', *args, **kwargs) + + +def IfcDoorType(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorType', 'IFC4X2', *args, **kwargs) + + +def IfcDraughtingPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedColour', 'IFC4X2', *args, **kwargs) + + +def IfcDraughtingPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedCurveFont', 'IFC4X2', *args, **kwargs) + + +def IfcDuctFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFitting', 'IFC4X2', *args, **kwargs) + + +def IfcDuctFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFittingType', 'IFC4X2', *args, **kwargs) + + +def IfcDuctSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegment', 'IFC4X2', *args, **kwargs) + + +def IfcDuctSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegmentType', 'IFC4X2', *args, **kwargs) + + +def IfcDuctSilencer(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencer', 'IFC4X2', *args, **kwargs) + + +def IfcDuctSilencerType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencerType', 'IFC4X2', *args, **kwargs) + + +def IfcEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcEdge', 'IFC4X2', *args, **kwargs) + + +def IfcEdgeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeCurve', 'IFC4X2', *args, **kwargs) + + +def IfcEdgeLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeLoop', 'IFC4X2', *args, **kwargs) + + +def IfcElectricAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricAppliance', 'IFC4X2', *args, **kwargs) + + +def IfcElectricApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricApplianceType', 'IFC4X2', *args, **kwargs) + + +def IfcElectricDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoard', 'IFC4X2', *args, **kwargs) + + +def IfcElectricDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoardType', 'IFC4X2', *args, **kwargs) + + +def IfcElectricFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDevice', 'IFC4X2', *args, **kwargs) + + +def IfcElectricFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDeviceType', 'IFC4X2', *args, **kwargs) + + +def IfcElectricGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGenerator', 'IFC4X2', *args, **kwargs) + + +def IfcElectricGeneratorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGeneratorType', 'IFC4X2', *args, **kwargs) + + +def IfcElectricMotor(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotor', 'IFC4X2', *args, **kwargs) + + +def IfcElectricMotorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotorType', 'IFC4X2', *args, **kwargs) + + +def IfcElectricTimeControl(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControl', 'IFC4X2', *args, **kwargs) + + +def IfcElectricTimeControlType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControlType', 'IFC4X2', *args, **kwargs) + + +def IfcElement(*args, **kwargs): return ifcopenshell.create_entity('IfcElement', 'IFC4X2', *args, **kwargs) + + +def IfcElementAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssembly', 'IFC4X2', *args, **kwargs) + + +def IfcElementAssemblyType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssemblyType', 'IFC4X2', *args, **kwargs) + + +def IfcElementComponent(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponent', 'IFC4X2', *args, **kwargs) + + +def IfcElementComponentType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponentType', 'IFC4X2', *args, **kwargs) + + +def IfcElementQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcElementQuantity', 'IFC4X2', *args, **kwargs) + + +def IfcElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementType', 'IFC4X2', *args, **kwargs) + + +def IfcElementarySurface(*args, **kwargs): return ifcopenshell.create_entity('IfcElementarySurface', 'IFC4X2', *args, **kwargs) + + +def IfcEllipse(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipse', 'IFC4X2', *args, **kwargs) + + +def IfcEllipseProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipseProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcEnergyConversionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDevice', 'IFC4X2', *args, **kwargs) + + +def IfcEnergyConversionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDeviceType', 'IFC4X2', *args, **kwargs) + + +def IfcEngine(*args, **kwargs): return ifcopenshell.create_entity('IfcEngine', 'IFC4X2', *args, **kwargs) + + +def IfcEngineType(*args, **kwargs): return ifcopenshell.create_entity('IfcEngineType', 'IFC4X2', *args, **kwargs) + + +def IfcEvaporativeCooler(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCooler', 'IFC4X2', *args, **kwargs) + + +def IfcEvaporativeCoolerType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCoolerType', 'IFC4X2', *args, **kwargs) + + +def IfcEvaporator(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporator', 'IFC4X2', *args, **kwargs) + + +def IfcEvaporatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporatorType', 'IFC4X2', *args, **kwargs) + + +def IfcEvent(*args, **kwargs): return ifcopenshell.create_entity('IfcEvent', 'IFC4X2', *args, **kwargs) + + +def IfcEventTime(*args, **kwargs): return ifcopenshell.create_entity('IfcEventTime', 'IFC4X2', *args, **kwargs) + + +def IfcEventType(*args, **kwargs): return ifcopenshell.create_entity('IfcEventType', 'IFC4X2', *args, **kwargs) + + +def IfcExtendedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcExtendedProperties', 'IFC4X2', *args, **kwargs) + + +def IfcExternalInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalInformation', 'IFC4X2', *args, **kwargs) + + +def IfcExternalReference(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReference', 'IFC4X2', *args, **kwargs) + + +def IfcExternalReferenceRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReferenceRelationship', 'IFC4X2', *args, **kwargs) + + +def IfcExternalSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialElement', 'IFC4X2', *args, **kwargs) + + +def IfcExternalSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialStructureElement', 'IFC4X2', *args, **kwargs) + + +def IfcExternallyDefinedHatchStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedHatchStyle', 'IFC4X2', *args, **kwargs) + + +def IfcExternallyDefinedSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedSurfaceStyle', 'IFC4X2', *args, **kwargs) + + +def IfcExternallyDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedTextFont', 'IFC4X2', *args, **kwargs) + + +def IfcExtrudedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolid', 'IFC4X2', *args, **kwargs) + + +def IfcExtrudedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolidTapered', 'IFC4X2', *args, **kwargs) + + +def IfcFace(*args, **kwargs): return ifcopenshell.create_entity('IfcFace', 'IFC4X2', *args, **kwargs) + + +def IfcFaceBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBasedSurfaceModel', 'IFC4X2', *args, **kwargs) + + +def IfcFaceBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBound', 'IFC4X2', *args, **kwargs) + + +def IfcFaceOuterBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceOuterBound', 'IFC4X2', *args, **kwargs) + + +def IfcFaceSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceSurface', 'IFC4X2', *args, **kwargs) + + +def IfcFacetedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrep', 'IFC4X2', *args, **kwargs) + + +def IfcFacetedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrepWithVoids', 'IFC4X2', *args, **kwargs) + + +def IfcFacility(*args, **kwargs): return ifcopenshell.create_entity('IfcFacility', 'IFC4X2', *args, **kwargs) + + +def IfcFacilityPart(*args, **kwargs): return ifcopenshell.create_entity('IfcFacilityPart', 'IFC4X2', *args, **kwargs) + + +def IfcFailureConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcFailureConnectionCondition', 'IFC4X2', *args, **kwargs) + + +def IfcFan(*args, **kwargs): return ifcopenshell.create_entity('IfcFan', 'IFC4X2', *args, **kwargs) + + +def IfcFanType(*args, **kwargs): return ifcopenshell.create_entity('IfcFanType', 'IFC4X2', *args, **kwargs) + + +def IfcFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcFastener', 'IFC4X2', *args, **kwargs) + + +def IfcFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFastenerType', 'IFC4X2', *args, **kwargs) + + +def IfcFeatureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElement', 'IFC4X2', *args, **kwargs) + + +def IfcFeatureElementAddition(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementAddition', 'IFC4X2', *args, **kwargs) + + +def IfcFeatureElementSubtraction(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementSubtraction', 'IFC4X2', *args, **kwargs) + + +def IfcFillAreaStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyle', 'IFC4X2', *args, **kwargs) + + +def IfcFillAreaStyleHatching(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleHatching', 'IFC4X2', *args, **kwargs) + + +def IfcFillAreaStyleTiles(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleTiles', 'IFC4X2', *args, **kwargs) + + +def IfcFilter(*args, **kwargs): return ifcopenshell.create_entity('IfcFilter', 'IFC4X2', *args, **kwargs) + + +def IfcFilterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFilterType', 'IFC4X2', *args, **kwargs) + + +def IfcFireSuppressionTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminal', 'IFC4X2', *args, **kwargs) + + +def IfcFireSuppressionTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminalType', 'IFC4X2', *args, **kwargs) + + +def IfcFixedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcFixedReferenceSweptAreaSolid', 'IFC4X2', *args, **kwargs) + + +def IfcFlowController(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowController', 'IFC4X2', *args, **kwargs) + + +def IfcFlowControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowControllerType', 'IFC4X2', *args, **kwargs) + + +def IfcFlowFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFitting', 'IFC4X2', *args, **kwargs) + + +def IfcFlowFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFittingType', 'IFC4X2', *args, **kwargs) + + +def IfcFlowInstrument(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrument', 'IFC4X2', *args, **kwargs) + + +def IfcFlowInstrumentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrumentType', 'IFC4X2', *args, **kwargs) + + +def IfcFlowMeter(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeter', 'IFC4X2', *args, **kwargs) + + +def IfcFlowMeterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeterType', 'IFC4X2', *args, **kwargs) + + +def IfcFlowMovingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDevice', 'IFC4X2', *args, **kwargs) + + +def IfcFlowMovingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDeviceType', 'IFC4X2', *args, **kwargs) + + +def IfcFlowSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegment', 'IFC4X2', *args, **kwargs) + + +def IfcFlowSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegmentType', 'IFC4X2', *args, **kwargs) + + +def IfcFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDevice', 'IFC4X2', *args, **kwargs) + + +def IfcFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDeviceType', 'IFC4X2', *args, **kwargs) + + +def IfcFlowTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminal', 'IFC4X2', *args, **kwargs) + + +def IfcFlowTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminalType', 'IFC4X2', *args, **kwargs) + + +def IfcFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDevice', 'IFC4X2', *args, **kwargs) + + +def IfcFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDeviceType', 'IFC4X2', *args, **kwargs) + + +def IfcFooting(*args, **kwargs): return ifcopenshell.create_entity('IfcFooting', 'IFC4X2', *args, **kwargs) + + +def IfcFootingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFootingType', 'IFC4X2', *args, **kwargs) + + +def IfcFurnishingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElement', 'IFC4X2', *args, **kwargs) + + +def IfcFurnishingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElementType', 'IFC4X2', *args, **kwargs) + + +def IfcFurniture(*args, **kwargs): return ifcopenshell.create_entity('IfcFurniture', 'IFC4X2', *args, **kwargs) + + +def IfcFurnitureType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnitureType', 'IFC4X2', *args, **kwargs) + + +def IfcGeographicElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElement', 'IFC4X2', *args, **kwargs) + + +def IfcGeographicElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElementType', 'IFC4X2', *args, **kwargs) + + +def IfcGeometricCurveSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricCurveSet', 'IFC4X2', *args, **kwargs) + + +def IfcGeometricRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationContext', 'IFC4X2', *args, **kwargs) + + +def IfcGeometricRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationItem', 'IFC4X2', *args, **kwargs) + + +def IfcGeometricRepresentationSubContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationSubContext', 'IFC4X2', *args, **kwargs) + + +def IfcGeometricSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricSet', 'IFC4X2', *args, **kwargs) + + +def IfcGrid(*args, **kwargs): return ifcopenshell.create_entity('IfcGrid', 'IFC4X2', *args, **kwargs) + + +def IfcGridAxis(*args, **kwargs): return ifcopenshell.create_entity('IfcGridAxis', 'IFC4X2', *args, **kwargs) + + +def IfcGridPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcGridPlacement', 'IFC4X2', *args, **kwargs) + + +def IfcGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcGroup', 'IFC4X2', *args, **kwargs) + + +def IfcHalfSpaceSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcHalfSpaceSolid', 'IFC4X2', *args, **kwargs) + + +def IfcHeatExchanger(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchanger', 'IFC4X2', *args, **kwargs) + + +def IfcHeatExchangerType(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchangerType', 'IFC4X2', *args, **kwargs) + + +def IfcHumidifier(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifier', 'IFC4X2', *args, **kwargs) + + +def IfcHumidifierType(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifierType', 'IFC4X2', *args, **kwargs) + + +def IfcIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcIShapeProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcImageTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcImageTexture', 'IFC4X2', *args, **kwargs) + + +def IfcIndexedColourMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedColourMap', 'IFC4X2', *args, **kwargs) + + +def IfcIndexedPolyCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolyCurve', 'IFC4X2', *args, **kwargs) + + +def IfcIndexedPolygonalFace(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFace', 'IFC4X2', *args, **kwargs) + + +def IfcIndexedPolygonalFaceWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFaceWithVoids', 'IFC4X2', *args, **kwargs) + + +def IfcIndexedTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTextureMap', 'IFC4X2', *args, **kwargs) + + +def IfcIndexedTriangleTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTriangleTextureMap', 'IFC4X2', *args, **kwargs) + + +def IfcInterceptor(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptor', 'IFC4X2', *args, **kwargs) + + +def IfcInterceptorType(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptorType', 'IFC4X2', *args, **kwargs) + + +def IfcIntersectionCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIntersectionCurve', 'IFC4X2', *args, **kwargs) + + +def IfcInventory(*args, **kwargs): return ifcopenshell.create_entity('IfcInventory', 'IFC4X2', *args, **kwargs) + + +def IfcIrregularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeries', 'IFC4X2', *args, **kwargs) + + +def IfcIrregularTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeriesValue', 'IFC4X2', *args, **kwargs) + + +def IfcJunctionBox(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBox', 'IFC4X2', *args, **kwargs) + + +def IfcJunctionBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBoxType', 'IFC4X2', *args, **kwargs) + + +def IfcLShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcLShapeProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcLaborResource(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResource', 'IFC4X2', *args, **kwargs) + + +def IfcLaborResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResourceType', 'IFC4X2', *args, **kwargs) + + +def IfcLagTime(*args, **kwargs): return ifcopenshell.create_entity('IfcLagTime', 'IFC4X2', *args, **kwargs) + + +def IfcLamp(*args, **kwargs): return ifcopenshell.create_entity('IfcLamp', 'IFC4X2', *args, **kwargs) + + +def IfcLampType(*args, **kwargs): return ifcopenshell.create_entity('IfcLampType', 'IFC4X2', *args, **kwargs) + + +def IfcLibraryInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryInformation', 'IFC4X2', *args, **kwargs) + + +def IfcLibraryReference(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryReference', 'IFC4X2', *args, **kwargs) + + +def IfcLightDistributionData(*args, **kwargs): return ifcopenshell.create_entity('IfcLightDistributionData', 'IFC4X2', *args, **kwargs) + + +def IfcLightFixture(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixture', 'IFC4X2', *args, **kwargs) + + +def IfcLightFixtureType(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixtureType', 'IFC4X2', *args, **kwargs) + + +def IfcLightIntensityDistribution(*args, **kwargs): return ifcopenshell.create_entity('IfcLightIntensityDistribution', 'IFC4X2', *args, **kwargs) + + +def IfcLightSource(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSource', 'IFC4X2', *args, **kwargs) + + +def IfcLightSourceAmbient(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceAmbient', 'IFC4X2', *args, **kwargs) + + +def IfcLightSourceDirectional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceDirectional', 'IFC4X2', *args, **kwargs) + + +def IfcLightSourceGoniometric(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceGoniometric', 'IFC4X2', *args, **kwargs) + + +def IfcLightSourcePositional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourcePositional', 'IFC4X2', *args, **kwargs) + + +def IfcLightSourceSpot(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceSpot', 'IFC4X2', *args, **kwargs) + + +def IfcLine(*args, **kwargs): return ifcopenshell.create_entity('IfcLine', 'IFC4X2', *args, **kwargs) + + +def IfcLineSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcLineSegment2D', 'IFC4X2', *args, **kwargs) + + +def IfcLinearPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPlacement', 'IFC4X2', *args, **kwargs) + + +def IfcLinearPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPositioningElement', 'IFC4X2', *args, **kwargs) + + +def IfcLocalPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLocalPlacement', 'IFC4X2', *args, **kwargs) + + +def IfcLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcLoop', 'IFC4X2', *args, **kwargs) + + +def IfcManifoldSolidBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcManifoldSolidBrep', 'IFC4X2', *args, **kwargs) + + +def IfcMapConversion(*args, **kwargs): return ifcopenshell.create_entity('IfcMapConversion', 'IFC4X2', *args, **kwargs) + + +def IfcMappedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcMappedItem', 'IFC4X2', *args, **kwargs) + + +def IfcMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterial', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialClassificationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialClassificationRelationship', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialConstituent(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituent', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialConstituentSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituentSet', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinition', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialDefinitionRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinitionRepresentation', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialLayer(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayer', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialLayerSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSet', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialLayerSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSetUsage', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialLayerWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerWithOffsets', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialList(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialList', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialProfile(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfile', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialProfileSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSet', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialProfileSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsage', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialProfileSetUsageTapering(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsageTapering', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialProfileWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileWithOffsets', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProperties', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialRelationship', 'IFC4X2', *args, **kwargs) + + +def IfcMaterialUsageDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialUsageDefinition', 'IFC4X2', *args, **kwargs) + + +def IfcMeasureWithUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMeasureWithUnit', 'IFC4X2', *args, **kwargs) + + +def IfcMechanicalFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastener', 'IFC4X2', *args, **kwargs) + + +def IfcMechanicalFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastenerType', 'IFC4X2', *args, **kwargs) + + +def IfcMedicalDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDevice', 'IFC4X2', *args, **kwargs) + + +def IfcMedicalDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDeviceType', 'IFC4X2', *args, **kwargs) + + +def IfcMember(*args, **kwargs): return ifcopenshell.create_entity('IfcMember', 'IFC4X2', *args, **kwargs) + + +def IfcMemberStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberStandardCase', 'IFC4X2', *args, **kwargs) + + +def IfcMemberType(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberType', 'IFC4X2', *args, **kwargs) + + +def IfcMetric(*args, **kwargs): return ifcopenshell.create_entity('IfcMetric', 'IFC4X2', *args, **kwargs) + + +def IfcMirroredProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcMirroredProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcMonetaryUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMonetaryUnit', 'IFC4X2', *args, **kwargs) + + +def IfcMotorConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnection', 'IFC4X2', *args, **kwargs) + + +def IfcMotorConnectionType(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnectionType', 'IFC4X2', *args, **kwargs) + + +def IfcNamedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcNamedUnit', 'IFC4X2', *args, **kwargs) + + +def IfcObject(*args, **kwargs): return ifcopenshell.create_entity('IfcObject', 'IFC4X2', *args, **kwargs) + + +def IfcObjectDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectDefinition', 'IFC4X2', *args, **kwargs) + + +def IfcObjectPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectPlacement', 'IFC4X2', *args, **kwargs) + + +def IfcObjective(*args, **kwargs): return ifcopenshell.create_entity('IfcObjective', 'IFC4X2', *args, **kwargs) + + +def IfcOccupant(*args, **kwargs): return ifcopenshell.create_entity('IfcOccupant', 'IFC4X2', *args, **kwargs) + + +def IfcOffsetCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve', 'IFC4X2', *args, **kwargs) + + +def IfcOffsetCurve2D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve2D', 'IFC4X2', *args, **kwargs) + + +def IfcOffsetCurve3D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve3D', 'IFC4X2', *args, **kwargs) + + +def IfcOffsetCurveByDistances(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurveByDistances', 'IFC4X2', *args, **kwargs) + + +def IfcOpenShell(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenShell', 'IFC4X2', *args, **kwargs) + + +def IfcOpeningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningElement', 'IFC4X2', *args, **kwargs) + + +def IfcOpeningStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningStandardCase', 'IFC4X2', *args, **kwargs) + + +def IfcOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganization', 'IFC4X2', *args, **kwargs) + + +def IfcOrganizationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganizationRelationship', 'IFC4X2', *args, **kwargs) + + +def IfcOrientationExpression(*args, **kwargs): return ifcopenshell.create_entity('IfcOrientationExpression', 'IFC4X2', *args, **kwargs) + + +def IfcOrientedEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcOrientedEdge', 'IFC4X2', *args, **kwargs) + + +def IfcOuterBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOuterBoundaryCurve', 'IFC4X2', *args, **kwargs) + + +def IfcOutlet(*args, **kwargs): return ifcopenshell.create_entity('IfcOutlet', 'IFC4X2', *args, **kwargs) + + +def IfcOutletType(*args, **kwargs): return ifcopenshell.create_entity('IfcOutletType', 'IFC4X2', *args, **kwargs) + + +def IfcOwnerHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcOwnerHistory', 'IFC4X2', *args, **kwargs) + + +def IfcParameterizedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcParameterizedProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcPath(*args, **kwargs): return ifcopenshell.create_entity('IfcPath', 'IFC4X2', *args, **kwargs) + + +def IfcPcurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPcurve', 'IFC4X2', *args, **kwargs) + + +def IfcPerformanceHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcPerformanceHistory', 'IFC4X2', *args, **kwargs) + + +def IfcPermeableCoveringProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPermeableCoveringProperties', 'IFC4X2', *args, **kwargs) + + +def IfcPermit(*args, **kwargs): return ifcopenshell.create_entity('IfcPermit', 'IFC4X2', *args, **kwargs) + + +def IfcPerson(*args, **kwargs): return ifcopenshell.create_entity('IfcPerson', 'IFC4X2', *args, **kwargs) + + +def IfcPersonAndOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcPersonAndOrganization', 'IFC4X2', *args, **kwargs) + + +def IfcPhysicalComplexQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalComplexQuantity', 'IFC4X2', *args, **kwargs) + + +def IfcPhysicalQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalQuantity', 'IFC4X2', *args, **kwargs) + + +def IfcPhysicalSimpleQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalSimpleQuantity', 'IFC4X2', *args, **kwargs) + + +def IfcPile(*args, **kwargs): return ifcopenshell.create_entity('IfcPile', 'IFC4X2', *args, **kwargs) + + +def IfcPileType(*args, **kwargs): return ifcopenshell.create_entity('IfcPileType', 'IFC4X2', *args, **kwargs) + + +def IfcPipeFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFitting', 'IFC4X2', *args, **kwargs) + + +def IfcPipeFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFittingType', 'IFC4X2', *args, **kwargs) + + +def IfcPipeSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegment', 'IFC4X2', *args, **kwargs) + + +def IfcPipeSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegmentType', 'IFC4X2', *args, **kwargs) + + +def IfcPixelTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcPixelTexture', 'IFC4X2', *args, **kwargs) + + +def IfcPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcPlacement', 'IFC4X2', *args, **kwargs) + + +def IfcPlanarBox(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarBox', 'IFC4X2', *args, **kwargs) + + +def IfcPlanarExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarExtent', 'IFC4X2', *args, **kwargs) + + +def IfcPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcPlane', 'IFC4X2', *args, **kwargs) + + +def IfcPlate(*args, **kwargs): return ifcopenshell.create_entity('IfcPlate', 'IFC4X2', *args, **kwargs) + + +def IfcPlateStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateStandardCase', 'IFC4X2', *args, **kwargs) + + +def IfcPlateType(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateType', 'IFC4X2', *args, **kwargs) + + +def IfcPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcPoint', 'IFC4X2', *args, **kwargs) + + +def IfcPointOnCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnCurve', 'IFC4X2', *args, **kwargs) + + +def IfcPointOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnSurface', 'IFC4X2', *args, **kwargs) + + +def IfcPolyLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyLoop', 'IFC4X2', *args, **kwargs) + + +def IfcPolygonalBoundedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalBoundedHalfSpace', 'IFC4X2', *args, **kwargs) + + +def IfcPolygonalFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalFaceSet', 'IFC4X2', *args, **kwargs) + + +def IfcPolyline(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyline', 'IFC4X2', *args, **kwargs) + + +def IfcPort(*args, **kwargs): return ifcopenshell.create_entity('IfcPort', 'IFC4X2', *args, **kwargs) + + +def IfcPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcPositioningElement', 'IFC4X2', *args, **kwargs) + + +def IfcPostalAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcPostalAddress', 'IFC4X2', *args, **kwargs) + + +def IfcPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedColour', 'IFC4X2', *args, **kwargs) + + +def IfcPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedCurveFont', 'IFC4X2', *args, **kwargs) + + +def IfcPreDefinedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedItem', 'IFC4X2', *args, **kwargs) + + +def IfcPreDefinedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedProperties', 'IFC4X2', *args, **kwargs) + + +def IfcPreDefinedPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedPropertySet', 'IFC4X2', *args, **kwargs) + + +def IfcPreDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedTextFont', 'IFC4X2', *args, **kwargs) + + +def IfcPresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationItem', 'IFC4X2', *args, **kwargs) + + +def IfcPresentationLayerAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerAssignment', 'IFC4X2', *args, **kwargs) + + +def IfcPresentationLayerWithStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerWithStyle', 'IFC4X2', *args, **kwargs) + + +def IfcPresentationStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyle', 'IFC4X2', *args, **kwargs) + + +def IfcPresentationStyleAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyleAssignment', 'IFC4X2', *args, **kwargs) + + +def IfcProcedure(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedure', 'IFC4X2', *args, **kwargs) + + +def IfcProcedureType(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedureType', 'IFC4X2', *args, **kwargs) + + +def IfcProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcProcess', 'IFC4X2', *args, **kwargs) + + +def IfcProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcProduct', 'IFC4X2', *args, **kwargs) + + +def IfcProductDefinitionShape(*args, **kwargs): return ifcopenshell.create_entity('IfcProductDefinitionShape', 'IFC4X2', *args, **kwargs) + + +def IfcProductRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcProductRepresentation', 'IFC4X2', *args, **kwargs) + + +def IfcProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileProperties', 'IFC4X2', *args, **kwargs) + + +def IfcProject(*args, **kwargs): return ifcopenshell.create_entity('IfcProject', 'IFC4X2', *args, **kwargs) + + +def IfcProjectLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectLibrary', 'IFC4X2', *args, **kwargs) + + +def IfcProjectOrder(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectOrder', 'IFC4X2', *args, **kwargs) + + +def IfcProjectedCRS(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectedCRS', 'IFC4X2', *args, **kwargs) + + +def IfcProjectionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectionElement', 'IFC4X2', *args, **kwargs) + + +def IfcProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcProperty', 'IFC4X2', *args, **kwargs) + + +def IfcPropertyAbstraction(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyAbstraction', 'IFC4X2', *args, **kwargs) + + +def IfcPropertyBoundedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyBoundedValue', 'IFC4X2', *args, **kwargs) + + +def IfcPropertyDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDefinition', 'IFC4X2', *args, **kwargs) + + +def IfcPropertyDependencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDependencyRelationship', 'IFC4X2', *args, **kwargs) + + +def IfcPropertyEnumeratedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeratedValue', 'IFC4X2', *args, **kwargs) + + +def IfcPropertyEnumeration(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeration', 'IFC4X2', *args, **kwargs) + + +def IfcPropertyListValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyListValue', 'IFC4X2', *args, **kwargs) + + +def IfcPropertyReferenceValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyReferenceValue', 'IFC4X2', *args, **kwargs) + + +def IfcPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySet', 'IFC4X2', *args, **kwargs) + + +def IfcPropertySetDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetDefinition', 'IFC4X2', *args, **kwargs) + + +def IfcPropertySetTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetTemplate', 'IFC4X2', *args, **kwargs) + + +def IfcPropertySingleValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySingleValue', 'IFC4X2', *args, **kwargs) + + +def IfcPropertyTableValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTableValue', 'IFC4X2', *args, **kwargs) + + +def IfcPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplate', 'IFC4X2', *args, **kwargs) + + +def IfcPropertyTemplateDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplateDefinition', 'IFC4X2', *args, **kwargs) + + +def IfcProtectiveDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDevice', 'IFC4X2', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnit', 'IFC4X2', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnitType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnitType', 'IFC4X2', *args, **kwargs) + + +def IfcProtectiveDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceType', 'IFC4X2', *args, **kwargs) + + +def IfcProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcProxy', 'IFC4X2', *args, **kwargs) + + +def IfcPump(*args, **kwargs): return ifcopenshell.create_entity('IfcPump', 'IFC4X2', *args, **kwargs) + + +def IfcPumpType(*args, **kwargs): return ifcopenshell.create_entity('IfcPumpType', 'IFC4X2', *args, **kwargs) + + +def IfcQuantityArea(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityArea', 'IFC4X2', *args, **kwargs) + + +def IfcQuantityCount(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityCount', 'IFC4X2', *args, **kwargs) + + +def IfcQuantityLength(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityLength', 'IFC4X2', *args, **kwargs) + + +def IfcQuantitySet(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantitySet', 'IFC4X2', *args, **kwargs) + + +def IfcQuantityTime(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityTime', 'IFC4X2', *args, **kwargs) + + +def IfcQuantityVolume(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityVolume', 'IFC4X2', *args, **kwargs) + + +def IfcQuantityWeight(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityWeight', 'IFC4X2', *args, **kwargs) + + +def IfcRailing(*args, **kwargs): return ifcopenshell.create_entity('IfcRailing', 'IFC4X2', *args, **kwargs) + + +def IfcRailingType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailingType', 'IFC4X2', *args, **kwargs) + + +def IfcRamp(*args, **kwargs): return ifcopenshell.create_entity('IfcRamp', 'IFC4X2', *args, **kwargs) + + +def IfcRampFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlight', 'IFC4X2', *args, **kwargs) + + +def IfcRampFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlightType', 'IFC4X2', *args, **kwargs) + + +def IfcRampType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampType', 'IFC4X2', *args, **kwargs) + + +def IfcRationalBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineCurveWithKnots', 'IFC4X2', *args, **kwargs) + + +def IfcRationalBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineSurfaceWithKnots', 'IFC4X2', *args, **kwargs) + + +def IfcRectangleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleHollowProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcRectangularPyramid(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularPyramid', 'IFC4X2', *args, **kwargs) + + +def IfcRectangularTrimmedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularTrimmedSurface', 'IFC4X2', *args, **kwargs) + + +def IfcRecurrencePattern(*args, **kwargs): return ifcopenshell.create_entity('IfcRecurrencePattern', 'IFC4X2', *args, **kwargs) + + +def IfcReference(*args, **kwargs): return ifcopenshell.create_entity('IfcReference', 'IFC4X2', *args, **kwargs) + + +def IfcReferent(*args, **kwargs): return ifcopenshell.create_entity('IfcReferent', 'IFC4X2', *args, **kwargs) + + +def IfcRegularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcRegularTimeSeries', 'IFC4X2', *args, **kwargs) + + +def IfcReinforcementBarProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementBarProperties', 'IFC4X2', *args, **kwargs) + + +def IfcReinforcementDefinitionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementDefinitionProperties', 'IFC4X2', *args, **kwargs) + + +def IfcReinforcingBar(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBar', 'IFC4X2', *args, **kwargs) + + +def IfcReinforcingBarType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBarType', 'IFC4X2', *args, **kwargs) + + +def IfcReinforcingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElement', 'IFC4X2', *args, **kwargs) + + +def IfcReinforcingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElementType', 'IFC4X2', *args, **kwargs) + + +def IfcReinforcingMesh(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMesh', 'IFC4X2', *args, **kwargs) + + +def IfcReinforcingMeshType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMeshType', 'IFC4X2', *args, **kwargs) + + +def IfcRelAggregates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAggregates', 'IFC4X2', *args, **kwargs) + + +def IfcRelAssigns(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssigns', 'IFC4X2', *args, **kwargs) + + +def IfcRelAssignsToActor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToActor', 'IFC4X2', *args, **kwargs) + + +def IfcRelAssignsToControl(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToControl', 'IFC4X2', *args, **kwargs) + + +def IfcRelAssignsToGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroup', 'IFC4X2', *args, **kwargs) + + +def IfcRelAssignsToGroupByFactor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroupByFactor', 'IFC4X2', *args, **kwargs) + + +def IfcRelAssignsToProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProcess', 'IFC4X2', *args, **kwargs) + + +def IfcRelAssignsToProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProduct', 'IFC4X2', *args, **kwargs) + + +def IfcRelAssignsToResource(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToResource', 'IFC4X2', *args, **kwargs) + + +def IfcRelAssociates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociates', 'IFC4X2', *args, **kwargs) + + +def IfcRelAssociatesApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesApproval', 'IFC4X2', *args, **kwargs) + + +def IfcRelAssociatesClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesClassification', 'IFC4X2', *args, **kwargs) + + +def IfcRelAssociatesConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesConstraint', 'IFC4X2', *args, **kwargs) + + +def IfcRelAssociatesDocument(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesDocument', 'IFC4X2', *args, **kwargs) + + +def IfcRelAssociatesLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesLibrary', 'IFC4X2', *args, **kwargs) + + +def IfcRelAssociatesMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesMaterial', 'IFC4X2', *args, **kwargs) + + +def IfcRelConnects(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnects', 'IFC4X2', *args, **kwargs) + + +def IfcRelConnectsElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsElements', 'IFC4X2', *args, **kwargs) + + +def IfcRelConnectsPathElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPathElements', 'IFC4X2', *args, **kwargs) + + +def IfcRelConnectsPortToElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPortToElement', 'IFC4X2', *args, **kwargs) + + +def IfcRelConnectsPorts(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPorts', 'IFC4X2', *args, **kwargs) + + +def IfcRelConnectsStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralActivity', 'IFC4X2', *args, **kwargs) + + +def IfcRelConnectsStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralMember', 'IFC4X2', *args, **kwargs) + + +def IfcRelConnectsWithEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithEccentricity', 'IFC4X2', *args, **kwargs) + + +def IfcRelConnectsWithRealizingElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithRealizingElements', 'IFC4X2', *args, **kwargs) + + +def IfcRelContainedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelContainedInSpatialStructure', 'IFC4X2', *args, **kwargs) + + +def IfcRelCoversBldgElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversBldgElements', 'IFC4X2', *args, **kwargs) + + +def IfcRelCoversSpaces(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversSpaces', 'IFC4X2', *args, **kwargs) + + +def IfcRelDeclares(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDeclares', 'IFC4X2', *args, **kwargs) + + +def IfcRelDecomposes(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDecomposes', 'IFC4X2', *args, **kwargs) + + +def IfcRelDefines(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefines', 'IFC4X2', *args, **kwargs) + + +def IfcRelDefinesByObject(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByObject', 'IFC4X2', *args, **kwargs) + + +def IfcRelDefinesByProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByProperties', 'IFC4X2', *args, **kwargs) + + +def IfcRelDefinesByTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByTemplate', 'IFC4X2', *args, **kwargs) + + +def IfcRelDefinesByType(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByType', 'IFC4X2', *args, **kwargs) + + +def IfcRelFillsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFillsElement', 'IFC4X2', *args, **kwargs) + + +def IfcRelFlowControlElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFlowControlElements', 'IFC4X2', *args, **kwargs) + + +def IfcRelInterferesElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelInterferesElements', 'IFC4X2', *args, **kwargs) + + +def IfcRelNests(*args, **kwargs): return ifcopenshell.create_entity('IfcRelNests', 'IFC4X2', *args, **kwargs) + + +def IfcRelPositions(*args, **kwargs): return ifcopenshell.create_entity('IfcRelPositions', 'IFC4X2', *args, **kwargs) + + +def IfcRelProjectsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelProjectsElement', 'IFC4X2', *args, **kwargs) + + +def IfcRelReferencedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelReferencedInSpatialStructure', 'IFC4X2', *args, **kwargs) + + +def IfcRelSequence(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSequence', 'IFC4X2', *args, **kwargs) + + +def IfcRelServicesBuildings(*args, **kwargs): return ifcopenshell.create_entity('IfcRelServicesBuildings', 'IFC4X2', *args, **kwargs) + + +def IfcRelSpaceBoundary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary', 'IFC4X2', *args, **kwargs) + + +def IfcRelSpaceBoundary1stLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary1stLevel', 'IFC4X2', *args, **kwargs) + + +def IfcRelSpaceBoundary2ndLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary2ndLevel', 'IFC4X2', *args, **kwargs) + + +def IfcRelVoidsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelVoidsElement', 'IFC4X2', *args, **kwargs) + + +def IfcRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcRelationship', 'IFC4X2', *args, **kwargs) + + +def IfcReparametrisedCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcReparametrisedCompositeCurveSegment', 'IFC4X2', *args, **kwargs) + + +def IfcRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentation', 'IFC4X2', *args, **kwargs) + + +def IfcRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationContext', 'IFC4X2', *args, **kwargs) + + +def IfcRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationItem', 'IFC4X2', *args, **kwargs) + + +def IfcRepresentationMap(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationMap', 'IFC4X2', *args, **kwargs) + + +def IfcResource(*args, **kwargs): return ifcopenshell.create_entity('IfcResource', 'IFC4X2', *args, **kwargs) + + +def IfcResourceApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceApprovalRelationship', 'IFC4X2', *args, **kwargs) + + +def IfcResourceConstraintRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceConstraintRelationship', 'IFC4X2', *args, **kwargs) + + +def IfcResourceLevelRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceLevelRelationship', 'IFC4X2', *args, **kwargs) + + +def IfcResourceTime(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceTime', 'IFC4X2', *args, **kwargs) + + +def IfcRevolvedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolid', 'IFC4X2', *args, **kwargs) + + +def IfcRevolvedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolidTapered', 'IFC4X2', *args, **kwargs) + + +def IfcRightCircularCone(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCone', 'IFC4X2', *args, **kwargs) + + +def IfcRightCircularCylinder(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCylinder', 'IFC4X2', *args, **kwargs) + + +def IfcRoof(*args, **kwargs): return ifcopenshell.create_entity('IfcRoof', 'IFC4X2', *args, **kwargs) + + +def IfcRoofType(*args, **kwargs): return ifcopenshell.create_entity('IfcRoofType', 'IFC4X2', *args, **kwargs) + + +def IfcRoot(*args, **kwargs): return ifcopenshell.create_entity('IfcRoot', 'IFC4X2', *args, **kwargs) + + +def IfcRoundedRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRoundedRectangleProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcSIUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcSIUnit', 'IFC4X2', *args, **kwargs) + + +def IfcSanitaryTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminal', 'IFC4X2', *args, **kwargs) + + +def IfcSanitaryTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminalType', 'IFC4X2', *args, **kwargs) + + +def IfcSchedulingTime(*args, **kwargs): return ifcopenshell.create_entity('IfcSchedulingTime', 'IFC4X2', *args, **kwargs) + + +def IfcSeamCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSeamCurve', 'IFC4X2', *args, **kwargs) + + +def IfcSectionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionProperties', 'IFC4X2', *args, **kwargs) + + +def IfcSectionReinforcementProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionReinforcementProperties', 'IFC4X2', *args, **kwargs) + + +def IfcSectionedSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolid', 'IFC4X2', *args, **kwargs) + + +def IfcSectionedSolidHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolidHorizontal', 'IFC4X2', *args, **kwargs) + + +def IfcSectionedSpine(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSpine', 'IFC4X2', *args, **kwargs) + + +def IfcSensor(*args, **kwargs): return ifcopenshell.create_entity('IfcSensor', 'IFC4X2', *args, **kwargs) + + +def IfcSensorType(*args, **kwargs): return ifcopenshell.create_entity('IfcSensorType', 'IFC4X2', *args, **kwargs) + + +def IfcShadingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDevice', 'IFC4X2', *args, **kwargs) + + +def IfcShadingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDeviceType', 'IFC4X2', *args, **kwargs) + + +def IfcShapeAspect(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeAspect', 'IFC4X2', *args, **kwargs) + + +def IfcShapeModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeModel', 'IFC4X2', *args, **kwargs) + + +def IfcShapeRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeRepresentation', 'IFC4X2', *args, **kwargs) + + +def IfcShellBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShellBasedSurfaceModel', 'IFC4X2', *args, **kwargs) + + +def IfcSimpleProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcSimpleProperty', 'IFC4X2', *args, **kwargs) + + +def IfcSimplePropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcSimplePropertyTemplate', 'IFC4X2', *args, **kwargs) + + +def IfcSite(*args, **kwargs): return ifcopenshell.create_entity('IfcSite', 'IFC4X2', *args, **kwargs) + + +def IfcSlab(*args, **kwargs): return ifcopenshell.create_entity('IfcSlab', 'IFC4X2', *args, **kwargs) + + +def IfcSlabElementedCase(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabElementedCase', 'IFC4X2', *args, **kwargs) + + +def IfcSlabStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabStandardCase', 'IFC4X2', *args, **kwargs) + + +def IfcSlabType(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabType', 'IFC4X2', *args, **kwargs) + + +def IfcSlippageConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcSlippageConnectionCondition', 'IFC4X2', *args, **kwargs) + + +def IfcSolarDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDevice', 'IFC4X2', *args, **kwargs) + + +def IfcSolarDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDeviceType', 'IFC4X2', *args, **kwargs) + + +def IfcSolidModel(*args, **kwargs): return ifcopenshell.create_entity('IfcSolidModel', 'IFC4X2', *args, **kwargs) + + +def IfcSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcSpace', 'IFC4X2', *args, **kwargs) + + +def IfcSpaceHeater(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeater', 'IFC4X2', *args, **kwargs) + + +def IfcSpaceHeaterType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeaterType', 'IFC4X2', *args, **kwargs) + + +def IfcSpaceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceType', 'IFC4X2', *args, **kwargs) + + +def IfcSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElement', 'IFC4X2', *args, **kwargs) + + +def IfcSpatialElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElementType', 'IFC4X2', *args, **kwargs) + + +def IfcSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElement', 'IFC4X2', *args, **kwargs) + + +def IfcSpatialStructureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElementType', 'IFC4X2', *args, **kwargs) + + +def IfcSpatialZone(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZone', 'IFC4X2', *args, **kwargs) + + +def IfcSpatialZoneType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZoneType', 'IFC4X2', *args, **kwargs) + + +def IfcSphere(*args, **kwargs): return ifcopenshell.create_entity('IfcSphere', 'IFC4X2', *args, **kwargs) + + +def IfcSphericalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSphericalSurface', 'IFC4X2', *args, **kwargs) + + +def IfcStackTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminal', 'IFC4X2', *args, **kwargs) + + +def IfcStackTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminalType', 'IFC4X2', *args, **kwargs) + + +def IfcStair(*args, **kwargs): return ifcopenshell.create_entity('IfcStair', 'IFC4X2', *args, **kwargs) + + +def IfcStairFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlight', 'IFC4X2', *args, **kwargs) + + +def IfcStairFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlightType', 'IFC4X2', *args, **kwargs) + + +def IfcStairType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairType', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAction', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralActivity', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralAnalysisModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAnalysisModel', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnection', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnectionCondition', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralCurveAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveAction', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralCurveConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveConnection', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralCurveMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMember', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralCurveMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMemberVarying', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralCurveReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveReaction', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralItem', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralLinearAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLinearAction', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralLoad(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoad', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralLoadCase(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadCase', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralLoadConfiguration(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadConfiguration', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralLoadGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadGroup', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralLoadLinearForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadLinearForce', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralLoadOrResult(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadOrResult', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralLoadPlanarForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadPlanarForce', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacement(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacement', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacementDistortion(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacementDistortion', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralLoadSingleForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForce', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralLoadSingleForceWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForceWarping', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralLoadStatic(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadStatic', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralLoadTemperature(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadTemperature', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralMember', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralPlanarAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPlanarAction', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralPointAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointAction', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralPointConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointConnection', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralPointReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointReaction', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralReaction', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralResultGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralResultGroup', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralSurfaceAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceAction', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralSurfaceConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceConnection', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralSurfaceMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMember', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralSurfaceMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMemberVarying', 'IFC4X2', *args, **kwargs) + + +def IfcStructuralSurfaceReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceReaction', 'IFC4X2', *args, **kwargs) + + +def IfcStyleModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStyleModel', 'IFC4X2', *args, **kwargs) + + +def IfcStyledItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledItem', 'IFC4X2', *args, **kwargs) + + +def IfcStyledRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledRepresentation', 'IFC4X2', *args, **kwargs) + + +def IfcSubContractResource(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResource', 'IFC4X2', *args, **kwargs) + + +def IfcSubContractResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResourceType', 'IFC4X2', *args, **kwargs) + + +def IfcSubedge(*args, **kwargs): return ifcopenshell.create_entity('IfcSubedge', 'IFC4X2', *args, **kwargs) + + +def IfcSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSurface', 'IFC4X2', *args, **kwargs) + + +def IfcSurfaceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurve', 'IFC4X2', *args, **kwargs) + + +def IfcSurfaceCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurveSweptAreaSolid', 'IFC4X2', *args, **kwargs) + + +def IfcSurfaceFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceFeature', 'IFC4X2', *args, **kwargs) + + +def IfcSurfaceOfLinearExtrusion(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfLinearExtrusion', 'IFC4X2', *args, **kwargs) + + +def IfcSurfaceOfRevolution(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfRevolution', 'IFC4X2', *args, **kwargs) + + +def IfcSurfaceReinforcementArea(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceReinforcementArea', 'IFC4X2', *args, **kwargs) + + +def IfcSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyle', 'IFC4X2', *args, **kwargs) + + +def IfcSurfaceStyleLighting(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleLighting', 'IFC4X2', *args, **kwargs) + + +def IfcSurfaceStyleRefraction(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRefraction', 'IFC4X2', *args, **kwargs) + + +def IfcSurfaceStyleRendering(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRendering', 'IFC4X2', *args, **kwargs) + + +def IfcSurfaceStyleShading(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleShading', 'IFC4X2', *args, **kwargs) + + +def IfcSurfaceStyleWithTextures(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleWithTextures', 'IFC4X2', *args, **kwargs) + + +def IfcSurfaceTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceTexture', 'IFC4X2', *args, **kwargs) + + +def IfcSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptAreaSolid', 'IFC4X2', *args, **kwargs) + + +def IfcSweptDiskSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolid', 'IFC4X2', *args, **kwargs) + + +def IfcSweptDiskSolidPolygonal(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolidPolygonal', 'IFC4X2', *args, **kwargs) + + +def IfcSweptSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptSurface', 'IFC4X2', *args, **kwargs) + + +def IfcSwitchingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDevice', 'IFC4X2', *args, **kwargs) + + +def IfcSwitchingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDeviceType', 'IFC4X2', *args, **kwargs) + + +def IfcSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcSystem', 'IFC4X2', *args, **kwargs) + + +def IfcSystemFurnitureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElement', 'IFC4X2', *args, **kwargs) + + +def IfcSystemFurnitureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElementType', 'IFC4X2', *args, **kwargs) + + +def IfcTShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTShapeProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcTable(*args, **kwargs): return ifcopenshell.create_entity('IfcTable', 'IFC4X2', *args, **kwargs) + + +def IfcTableColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcTableColumn', 'IFC4X2', *args, **kwargs) + + +def IfcTableRow(*args, **kwargs): return ifcopenshell.create_entity('IfcTableRow', 'IFC4X2', *args, **kwargs) + + +def IfcTank(*args, **kwargs): return ifcopenshell.create_entity('IfcTank', 'IFC4X2', *args, **kwargs) + + +def IfcTankType(*args, **kwargs): return ifcopenshell.create_entity('IfcTankType', 'IFC4X2', *args, **kwargs) + + +def IfcTask(*args, **kwargs): return ifcopenshell.create_entity('IfcTask', 'IFC4X2', *args, **kwargs) + + +def IfcTaskTime(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTime', 'IFC4X2', *args, **kwargs) + + +def IfcTaskTimeRecurring(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTimeRecurring', 'IFC4X2', *args, **kwargs) + + +def IfcTaskType(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskType', 'IFC4X2', *args, **kwargs) + + +def IfcTelecomAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcTelecomAddress', 'IFC4X2', *args, **kwargs) + + +def IfcTendon(*args, **kwargs): return ifcopenshell.create_entity('IfcTendon', 'IFC4X2', *args, **kwargs) + + +def IfcTendonAnchor(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchor', 'IFC4X2', *args, **kwargs) + + +def IfcTendonAnchorType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchorType', 'IFC4X2', *args, **kwargs) + + +def IfcTendonConduit(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduit', 'IFC4X2', *args, **kwargs) + + +def IfcTendonConduitType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduitType', 'IFC4X2', *args, **kwargs) + + +def IfcTendonType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonType', 'IFC4X2', *args, **kwargs) + + +def IfcTessellatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedFaceSet', 'IFC4X2', *args, **kwargs) + + +def IfcTessellatedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedItem', 'IFC4X2', *args, **kwargs) + + +def IfcTextLiteral(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteral', 'IFC4X2', *args, **kwargs) + + +def IfcTextLiteralWithExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteralWithExtent', 'IFC4X2', *args, **kwargs) + + +def IfcTextStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyle', 'IFC4X2', *args, **kwargs) + + +def IfcTextStyleFontModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleFontModel', 'IFC4X2', *args, **kwargs) + + +def IfcTextStyleForDefinedFont(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleForDefinedFont', 'IFC4X2', *args, **kwargs) + + +def IfcTextStyleTextModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleTextModel', 'IFC4X2', *args, **kwargs) + + +def IfcTextureCoordinate(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinate', 'IFC4X2', *args, **kwargs) + + +def IfcTextureCoordinateGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateGenerator', 'IFC4X2', *args, **kwargs) + + +def IfcTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureMap', 'IFC4X2', *args, **kwargs) + + +def IfcTextureVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertex', 'IFC4X2', *args, **kwargs) + + +def IfcTextureVertexList(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertexList', 'IFC4X2', *args, **kwargs) + + +def IfcTimePeriod(*args, **kwargs): return ifcopenshell.create_entity('IfcTimePeriod', 'IFC4X2', *args, **kwargs) + + +def IfcTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeries', 'IFC4X2', *args, **kwargs) + + +def IfcTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeriesValue', 'IFC4X2', *args, **kwargs) + + +def IfcTopologicalRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologicalRepresentationItem', 'IFC4X2', *args, **kwargs) + + +def IfcTopologyRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologyRepresentation', 'IFC4X2', *args, **kwargs) + + +def IfcToroidalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcToroidalSurface', 'IFC4X2', *args, **kwargs) + + +def IfcTransformer(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformer', 'IFC4X2', *args, **kwargs) + + +def IfcTransformerType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformerType', 'IFC4X2', *args, **kwargs) + + +def IfcTransitionCurveSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcTransitionCurveSegment2D', 'IFC4X2', *args, **kwargs) + + +def IfcTransportElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElement', 'IFC4X2', *args, **kwargs) + + +def IfcTransportElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElementType', 'IFC4X2', *args, **kwargs) + + +def IfcTrapeziumProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTrapeziumProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcTriangulatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedFaceSet', 'IFC4X2', *args, **kwargs) + + +def IfcTriangulatedIrregularNetwork(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedIrregularNetwork', 'IFC4X2', *args, **kwargs) + + +def IfcTrimmedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcTrimmedCurve', 'IFC4X2', *args, **kwargs) + + +def IfcTubeBundle(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundle', 'IFC4X2', *args, **kwargs) + + +def IfcTubeBundleType(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundleType', 'IFC4X2', *args, **kwargs) + + +def IfcTypeObject(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeObject', 'IFC4X2', *args, **kwargs) + + +def IfcTypeProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProcess', 'IFC4X2', *args, **kwargs) + + +def IfcTypeProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProduct', 'IFC4X2', *args, **kwargs) + + +def IfcTypeResource(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeResource', 'IFC4X2', *args, **kwargs) + + +def IfcUShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcUShapeProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcUnitAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitAssignment', 'IFC4X2', *args, **kwargs) + + +def IfcUnitaryControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElement', 'IFC4X2', *args, **kwargs) + + +def IfcUnitaryControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElementType', 'IFC4X2', *args, **kwargs) + + +def IfcUnitaryEquipment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipment', 'IFC4X2', *args, **kwargs) + + +def IfcUnitaryEquipmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipmentType', 'IFC4X2', *args, **kwargs) + + +def IfcValve(*args, **kwargs): return ifcopenshell.create_entity('IfcValve', 'IFC4X2', *args, **kwargs) + + +def IfcValveType(*args, **kwargs): return ifcopenshell.create_entity('IfcValveType', 'IFC4X2', *args, **kwargs) + + +def IfcVector(*args, **kwargs): return ifcopenshell.create_entity('IfcVector', 'IFC4X2', *args, **kwargs) + + +def IfcVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcVertex', 'IFC4X2', *args, **kwargs) + + +def IfcVertexLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexLoop', 'IFC4X2', *args, **kwargs) + + +def IfcVertexPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexPoint', 'IFC4X2', *args, **kwargs) + + +def IfcVibrationDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamper', 'IFC4X2', *args, **kwargs) + + +def IfcVibrationDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamperType', 'IFC4X2', *args, **kwargs) + + +def IfcVibrationIsolator(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolator', 'IFC4X2', *args, **kwargs) + + +def IfcVibrationIsolatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolatorType', 'IFC4X2', *args, **kwargs) + + +def IfcVirtualElement(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualElement', 'IFC4X2', *args, **kwargs) + + +def IfcVirtualGridIntersection(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualGridIntersection', 'IFC4X2', *args, **kwargs) + + +def IfcVoidingFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcVoidingFeature', 'IFC4X2', *args, **kwargs) + + +def IfcWall(*args, **kwargs): return ifcopenshell.create_entity('IfcWall', 'IFC4X2', *args, **kwargs) + + +def IfcWallElementedCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallElementedCase', 'IFC4X2', *args, **kwargs) + + +def IfcWallStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallStandardCase', 'IFC4X2', *args, **kwargs) + + +def IfcWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcWallType', 'IFC4X2', *args, **kwargs) + + +def IfcWasteTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminal', 'IFC4X2', *args, **kwargs) + + +def IfcWasteTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminalType', 'IFC4X2', *args, **kwargs) + + +def IfcWindow(*args, **kwargs): return ifcopenshell.create_entity('IfcWindow', 'IFC4X2', *args, **kwargs) + + +def IfcWindowLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowLiningProperties', 'IFC4X2', *args, **kwargs) + + +def IfcWindowPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowPanelProperties', 'IFC4X2', *args, **kwargs) + + +def IfcWindowStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowStandardCase', 'IFC4X2', *args, **kwargs) + + +def IfcWindowStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowStyle', 'IFC4X2', *args, **kwargs) + + +def IfcWindowType(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowType', 'IFC4X2', *args, **kwargs) + + +def IfcWorkCalendar(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkCalendar', 'IFC4X2', *args, **kwargs) + + +def IfcWorkControl(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkControl', 'IFC4X2', *args, **kwargs) + + +def IfcWorkPlan(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkPlan', 'IFC4X2', *args, **kwargs) + + +def IfcWorkSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkSchedule', 'IFC4X2', *args, **kwargs) + + +def IfcWorkTime(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkTime', 'IFC4X2', *args, **kwargs) + + +def IfcZShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcZShapeProfileDef', 'IFC4X2', *args, **kwargs) + + +def IfcZone(*args, **kwargs): return ifcopenshell.create_entity('IfcZone', 'IFC4X2', *args, **kwargs) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcBoxAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcBoxAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['top-left','top-middle','top-right','middle-left','center','middle-right','bottom-left','bottom-middle','bottom-right'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCardinalPointReference_GreaterThanZero: + SCOPE = "type" + TYPE_NAME = "IfcCardinalPointReference" + RULE_NAME = "GreaterThanZero" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCompoundPlaneAngleMeasure_MinutesInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MinutesInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[2 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_SecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "SecondsInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[3 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_MicrosecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MicrosecondsInRange" + + @staticmethod + def __call__(self): + + + assert (sizeof(self) == 3) or ((abs(self[4 - 1])) < 1000000) + + + + +class IfcCompoundPlaneAngleMeasure_ConsistentSign: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "ConsistentSign" + + @staticmethod + def __call__(self): + + + assert (((self[1 - 1]) >= 0) and ((self[2 - 1]) >= 0) and ((self[3 - 1]) >= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) >= 0))) or (((self[1 - 1]) <= 0) and ((self[2 - 1]) <= 0) and ((self[3 - 1]) <= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) <= 0))) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDayInMonthNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInMonthNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 31 + + + + + +class IfcDayInWeekNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInWeekNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 7 + + + + + + + + + + + + + + + + + +class IfcDimensionCount_WR1: + SCOPE = "type" + TYPE_NAME = "IfcDimensionCount" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0 < self <= 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFontStyle_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontStyle" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','italic','oblique'] + + + + + +class IfcFontVariant_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontVariant" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps'] + + + + + +class IfcFontWeight_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontWeight" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps','100','200','300','400','500','600','700','800','900'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcHeatingValueMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcHeatingValueMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMonthInYearNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcMonthInYearNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 12 + + + + + + + + +class IfcNonNegativeLengthMeasure_NotNegative: + SCOPE = "type" + TYPE_NAME = "IfcNonNegativeLengthMeasure" + RULE_NAME = "NotNegative" + + @staticmethod + def __call__(self): + + + assert self >= 0. + + + + + +class IfcNormalisedRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcNormalisedRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPHMeasure_WR21: + SCOPE = "type" + TYPE_NAME = "IfcPHMeasure" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 14.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPositiveInteger_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveInteger" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + +class IfcPositiveLengthMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveLengthMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositivePlaneAngleMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositivePlaneAngleMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositiveRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcSpecularRoughness_WR1: + SCOPE = "type" + TYPE_NAME = "IfcSpecularRoughness" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTextAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['left','right','center','justify'] + + + + + +class IfcTextDecoration_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextDecoration" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['none','underline','overline','line-through','blink'] + + + + + + + + + + + + + + +class IfcTextTransformation_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextTransformation" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['capitalize','uppercase','lowercase','none'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcActorRole_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcActorRole" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + role = self.Role + + assert (role != IfcRoleEnum.USERDEFINED) or ((role == IfcRoleEnum.USERDEFINED) and exists(self.UserDefinedRole)) + + + + + +class IfcActuator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcActuator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcactuatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcActuatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + purpose = self.Purpose + + assert (not exists(purpose)) or ((purpose != IfcAddressTypeEnum.USERDEFINED) or ((purpose == IfcAddressTypeEnum.USERDEFINED) and exists(self.UserDefinedPurpose))) + + + + + +class IfcAdvancedBrep_HasAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrep" + RULE_NAME = "HasAdvancedFaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([afs for afs in self.Outer.CfsFaces if not 'ifc4x2.ifcadvancedface' in typeof(afs)])) == 0 + + + + + +class IfcAdvancedBrepWithVoids_VoidsHaveAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrepWithVoids" + RULE_NAME = "VoidsHaveAdvancedFaces" + + @staticmethod + def __call__(self): + voids = self.Voids + + assert (sizeof([vsh for vsh in voids if (sizeof([afs for afs in vsh.CfsFaces if not 'ifc4x2.ifcadvancedface' in typeof(afs)])) == 0])) == 0 + + + + + +class IfcAdvancedFace_ApplicableSurface: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableSurface" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x2.ifcelementarysurface','ifc4x2.ifcsweptsurface','ifc4x2.ifcbsplinesurface'] * typeof(self.FaceSurface))) == 1 + + + + +class IfcAdvancedFace_RequiresEdgeCurve: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "RequiresEdgeCurve" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x2.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not 'ifc4x2.ifcedgecurve' in typeof(oe.EdgeElement)])) == 0])) == 0 + + + + +class IfcAdvancedFace_ApplicableEdgeCurves: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableEdgeCurves" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x2.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not (sizeof(['ifc4x2.ifcline','ifc4x2.ifcconic','ifc4x2.ifcpolyline','ifc4x2.ifcbsplinecurve'] * typeof(oe.EdgeElement.EdgeGeometry))) == 1])) == 0])) == 0 + + + + + +class IfcAirTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcairterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminalBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcairterminalboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirToAirHeatRecovery_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirToAirHeatRecovery_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcairtoairheatrecoverytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirToAirHeatRecoveryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecoveryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAlarm_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAlarm_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcalarmtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAlarmType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarmType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcApproval_HasIdentifierOrName: + SCOPE = "entity" + TYPE_NAME = "IfcApproval" + RULE_NAME = "HasIdentifierOrName" + + @staticmethod + def __call__(self): + identifier = self.Identifier + name = self.Name + + assert exists(identifier) or exists(name) + + + + + + + + +class IfcArbitraryClosedProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert outercurve.Dim == 2 + + + + +class IfcArbitraryClosedProfileDef_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x2.ifcline' in typeof(outercurve) + + + + +class IfcArbitraryClosedProfileDef_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x2.ifcoffsetcurve2d' in typeof(outercurve) + + + + + +class IfcArbitraryOpenProfileDef_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert ('ifc4x2.ifccenterlineprofiledef' in typeof(self)) or (self.ProfileType == IfcProfileTypeEnum.CURVE) + + + + +class IfcArbitraryOpenProfileDef_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + curve = self.Curve + + assert curve.Dim == 2 + + + + + +class IfcArbitraryProfileDefWithVoids_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == area + + + + +class IfcArbitraryProfileDefWithVoids_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if temp.Dim != 2])) == 0 + + + + +class IfcArbitraryProfileDefWithVoids_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if 'ifc4x2.ifcline' in typeof(temp)])) == 0 + + + + + + + + +class IfcAsymmetricIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + bottomflangethickness = self.BottomFlangeThickness + topflangethickness = self.TopFlangeThickness + + assert (not exists(topflangethickness)) or ((bottomflangethickness + topflangethickness) < overalldepth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + + assert (webthickness < bottomflangewidth) and (webthickness < topflangewidth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidBottomFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidBottomFilletRadius" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + bottomflangefilletradius = self.BottomFlangeFilletRadius + + assert (not exists(bottomflangefilletradius)) or (bottomflangefilletradius <= ((bottomflangewidth - webthickness) / 2.)) + + + + +class IfcAsymmetricIShapeProfileDef_ValidTopFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidTopFilletRadius" + + @staticmethod + def __call__(self): + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + topflangefilletradius = self.TopFlangeFilletRadius + + assert (not exists(topflangefilletradius)) or (topflangefilletradius <= ((topflangewidth - webthickness) / 2.)) + + + + + +class IfcAudioVisualAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAudioVisualAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcaudiovisualappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAudioVisualApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAxis1Placement_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis1Placement_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +def calc_IfcAxis1Placement_Z(self): + axis = self.Axis + return \ + nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + + + + +class IfcAxis2Placement2D_RefDirIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "RefDirIs2D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 2) + + + + +class IfcAxis2Placement2D_LocationIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIs2D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 2 + + + + +def calc_IfcAxis2Placement2D_P(self): + refdirection = self.RefDirection + return \ + IfcBuild2Axes(refdirection) + + + + +class IfcAxis2Placement3D_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis2Placement3D_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis2Placement3D_RefDirIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "RefDirIs3D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 3) + + + + +class IfcAxis2Placement3D_AxisToRefDirPosition: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisToRefDirPosition" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + +class IfcAxis2Placement3D_AxisAndRefDirProvision: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisAndRefDirProvision" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert not exists(axis) ^ exists(refdirection) + + + + +def calc_IfcAxis2Placement3D_P(self): + axis = self.Axis + refdirection = self.RefDirection + return \ + IfcBuildAxes(axis,refdirection) + + + + +class IfcBSplineCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + controlpointslist = self.ControlPointsList + + assert (sizeof([temp for temp in controlpointslist if temp.Dim != (controlpointslist[1 - 1].Dim)])) == 0 + + + + +def calc_IfcBSplineCurve_UpperIndexOnControlPoints(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineCurve_ControlPoints(self): + controlpointslist = self.ControlPointsList + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + return \ + IfcListToArray(controlpointslist,0,upperindexoncontrolpoints) + + + + +class IfcBSplineCurveWithKnots_ConsistentBSpline: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "ConsistentBSpline" + + @staticmethod + def __call__(self): + degree = self.Degree + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + knotmultiplicities = self.KnotMultiplicities + knots = self.Knots + upperindexonknots = self.UpperIndexOnKnots + + assert IfcConstraintsParamBSpline(degree,upperindexonknots,upperindexoncontrolpoints,knotmultiplicities,knots) + + + + +class IfcBSplineCurveWithKnots_CorrespondingKnotLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "CorrespondingKnotLists" + + @staticmethod + def __call__(self): + knotmultiplicities = self.KnotMultiplicities + upperindexonknots = self.UpperIndexOnKnots + + assert sizeof(knotmultiplicities) == upperindexonknots + + + + +def calc_IfcBSplineCurveWithKnots_UpperIndexOnKnots(self): + knots = self.Knots + return \ + sizeof(knots) + + + + +def calc_IfcBSplineSurface_UUpper(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineSurface_VUpper(self): + controlpointslist = self.ControlPointsList + return \ + (sizeof(controlpointslist[1 - 1])) - 1 + + + +def calc_IfcBSplineSurface_ControlPoints(self): + controlpointslist = self.ControlPointsList + uupper = self.UUpper + vupper = self.VUpper + return \ + IfcMakeArrayOfArray(controlpointslist,0,uupper,0,vupper) + + + + +class IfcBSplineSurfaceWithKnots_UDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "UDirectionConstraints" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + uknots = self.UKnots + knotuupper = self.KnotUUpper + + assert IfcConstraintsParamBSpline(self.UDegree,knotuupper,self.UUpper,umultiplicities,uknots) + + + + +class IfcBSplineSurfaceWithKnots_VDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "VDirectionConstraints" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + vknots = self.VKnots + knotvupper = self.KnotVUpper + + assert IfcConstraintsParamBSpline(self.VDegree,knotvupper,self.VUpper,vmultiplicities,vknots) + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingULists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingULists" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + knotuupper = self.KnotUUpper + + assert sizeof(umultiplicities) == knotuupper + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingVLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingVLists" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + knotvupper = self.KnotVUpper + + assert sizeof(vmultiplicities) == knotvupper + + + + +def calc_IfcBSplineSurfaceWithKnots_KnotVUpper(self): + vknots = self.VKnots + return \ + sizeof(vknots) + + + +def calc_IfcBSplineSurfaceWithKnots_KnotUUpper(self): + uknots = self.UKnots + return \ + sizeof(uknots) + + + + +class IfcBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBeamStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcBeamStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x2.ifcrelassociates.relatedobjects') if ('ifc4x2.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x2.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBearing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBearing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcbearingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBearingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBlobTexture_SupportedRasterFormat: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "SupportedRasterFormat" + + @staticmethod + def __call__(self): + + + assert self.RasterFormat in ['bmp','jpg','gif','png'] + + + + +class IfcBlobTexture_RasterCodeByteStream: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "RasterCodeByteStream" + + @staticmethod + def __call__(self): + rastercode = self.RasterCode + + assert (blength(rastercode) % 8) == 0 + + + + + + + + +class IfcBoiler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBoiler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcboilertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBoilerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoilerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBooleanClippingResult_FirstOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "FirstOperandType" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert ('ifc4x2.ifcsweptareasolid' in typeof(firstoperand)) or ('ifc4x2.ifcsweptdiscsolid' in typeof(firstoperand)) or ('ifc4x2.ifcbooleanclippingresult' in typeof(firstoperand)) + + + + +class IfcBooleanClippingResult_SecondOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "SecondOperandType" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert 'ifc4x2.ifchalfspacesolid' in typeof(secondoperand) + + + + +class IfcBooleanClippingResult_OperatorType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "OperatorType" + + @staticmethod + def __call__(self): + operator = self.Operator + + assert operator == difference + + + + + +class IfcBooleanResult_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + secondoperand = self.SecondOperand + + assert firstoperand.Dim == secondoperand.Dim + + + + +class IfcBooleanResult_FirstOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "FirstOperandClosed" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert (not 'ifc4x2.ifctessellatedfaceset' in typeof(firstoperand)) or (exists(firstoperand.Closed) and firstoperand.Closed) + + + + +class IfcBooleanResult_SecondOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SecondOperandClosed" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert (not 'ifc4x2.ifctessellatedfaceset' in typeof(secondoperand)) or (exists(secondoperand.Closed) and secondoperand.Closed) + + + + +def calc_IfcBooleanResult_Dim(self): + firstoperand = self.FirstOperand + return \ + firstoperand.Dim + + + + + + + +class IfcBoundaryCurve_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBoundaryCurve" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + + + assert self.ClosedCurve + + + + + + + + + + + + + + + + + + + + + + + +def calc_IfcBoundingBox_Dim(self): + + return \ + 3 + + + + +class IfcBoxedHalfSpace_UnboundedSurface: + SCOPE = "entity" + TYPE_NAME = "IfcBoxedHalfSpace" + RULE_NAME = "UnboundedSurface" + + @staticmethod + def __call__(self): + + + assert not 'ifc4x2.ifccurveboundedplane' in typeof(self.BaseSurface) + + + + + + + + + + + + + + +class IfcBuildingElement_MaxOneMaterialAssociation: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElement" + RULE_NAME = "MaxOneMaterialAssociation" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.HasAssociations if 'ifc4x2.ifcrelassociatesmaterial' in typeof(temp)])) <= 1 + + + + + +class IfcBuildingElementPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementPart_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcbuildingelementparttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementPartType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPartType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBuildingElementProxy_HasObjectName: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "HasObjectName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcBuildingElementProxy_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementProxy_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcbuildingelementproxytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementProxyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcBurner_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBurner_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcburnertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBurnerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurnerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCShapeProfileDef_ValidGirth: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidGirth" + + @staticmethod + def __call__(self): + depth = self.Depth + girth = self.Girth + + assert girth < (depth / 2.) + + + + +class IfcCShapeProfileDef_ValidInternalFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidInternalFilletRadius" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + internalfilletradius = self.InternalFilletRadius + + assert (not exists(internalfilletradius)) or ((internalfilletradius <= ((width / 2.) - wallthickness)) and (internalfilletradius <= ((depth / 2.) - wallthickness))) + + + + +class IfcCShapeProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + + assert (wallthickness < (width / 2.)) and (wallthickness < (depth / 2.)) + + + + + +class IfcCableCarrierFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifccablecarrierfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableCarrierSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifccablecarriersegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifccablefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifccablesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCaissonFoundation_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCaissonFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifccaissonfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCaissonFoundationType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundationType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCartesianPoint_CP2Dor3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianPoint" + RULE_NAME = "CP2Dor3D" + + @staticmethod + def __call__(self): + coordinates = self.Coordinates + + assert hiindex(coordinates) >= 2 + + + + +def calc_IfcCartesianPoint_Dim(self): + coordinates = self.Coordinates + return \ + hiindex(coordinates) + + + + +def calc_IfcCartesianPointList_Dim(self): + + return \ + IfcPointListDim(self) + + + + + + + + + + +class IfcCartesianTransformationOperator_ScaleGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator" + RULE_NAME = "ScaleGreaterZero" + + @staticmethod + def __call__(self): + scl = self.Scl + + assert scl > 0.0 + + + + +def calc_IfcCartesianTransformationOperator_Scl(self): + scale = self.Scale + return \ + nvl(scale,1.0) + + + +def calc_IfcCartesianTransformationOperator_Dim(self): + localorigin = self.LocalOrigin + return \ + localorigin.Dim + + + + +class IfcCartesianTransformationOperator2D_DimEqual2: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "DimEqual2" + + @staticmethod + def __call__(self): + + + assert self.Dim == 2 + + + + +class IfcCartesianTransformationOperator2D_Axis1Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis1Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 2) + + + + +class IfcCartesianTransformationOperator2D_Axis2Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis2Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 2) + + + + +def calc_IfcCartesianTransformationOperator2D_U(self): + + return \ + IfcBaseAxis(2,self.Axis1,self.Axis2,None) + + + + +class IfcCartesianTransformationOperator2DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator2DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + + +class IfcCartesianTransformationOperator3D_DimIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "DimIs3D" + + @staticmethod + def __call__(self): + + + assert self.Dim == 3 + + + + +class IfcCartesianTransformationOperator3D_Axis1Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis1Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis2Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis2Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis3Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis3Is3D" + + @staticmethod + def __call__(self): + axis3 = self.Axis3 + + assert (not exists(axis3)) or (axis3.Dim == 3) + + + + +def calc_IfcCartesianTransformationOperator3D_U(self): + axis3 = self.Axis3 + return \ + IfcBaseAxis(3,self.Axis1,self.Axis2,axis3) + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale3GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale3GreaterZero" + + @staticmethod + def __call__(self): + scl3 = self.Scl3 + + assert scl3 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl3(self): + scale3 = self.Scale3 + return \ + nvl(scale3,self.Scl) + + + + + + + +class IfcChiller_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChiller_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcchillertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChillerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChillerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcChimney_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChimney_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcchimneytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChimneyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimneyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcCircleHollowProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCircleHollowProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert wallthickness < self.Radius + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoil_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifccoiltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoilType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoilType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcColumn_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcColumn_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifccolumntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcColumnStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcColumnStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x2.ifcrelassociates.relatedobjects') if ('ifc4x2.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x2.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcColumnType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumnType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifccommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcComplexProperty_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert (sizeof([temp for temp in hasproperties if self == temp])) == 0 + + + + +class IfcComplexProperty_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + +class IfcComplexPropertyTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + +class IfcComplexPropertyTemplate_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert (sizeof([temp for temp in haspropertytemplates if self == temp])) == 0 + + + + + +class IfcCompositeCurve_CurveContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "CurveContinuous" + + @staticmethod + def __call__(self): + segments = self.Segments + closedcurve = self.ClosedCurve + + assert ((not closedcurve) and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 1)) or (closedcurve and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 0)) + + + + +class IfcCompositeCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (sizeof([temp for temp in segments if temp.Dim != (segments[1 - 1].Dim)])) == 0 + + + + +def calc_IfcCompositeCurve_NSegments(self): + segments = self.Segments + return \ + sizeof(segments) + + + +def calc_IfcCompositeCurve_ClosedCurve(self): + segments = self.Segments + nsegments = self.NSegments + return \ + (segments[nsegments - 1].Transition) != discontinuous + + + + +class IfcCompositeCurveOnSurface_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveOnSurface" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + + assert sizeof(basissurface) > 0 + + + + +def calc_IfcCompositeCurveOnSurface_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + +class IfcCompositeCurveSegment_ParentIsBoundedCurve: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveSegment" + RULE_NAME = "ParentIsBoundedCurve" + + @staticmethod + def __call__(self): + parentcurve = self.ParentCurve + + assert 'ifc4x2.ifcboundedcurve' in typeof(parentcurve) + + + + +def calc_IfcCompositeCurveSegment_Dim(self): + parentcurve = self.ParentCurve + return \ + parentcurve.Dim + + + + +class IfcCompositeProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if temp.ProfileType != (profiles[1 - 1].ProfileType)])) == 0 + + + + +class IfcCompositeProfileDef_NoRecursion: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "NoRecursion" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if 'ifc4x2.ifccompositeprofiledef' in typeof(temp)])) == 0 + + + + + +class IfcCompressor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCompressor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifccompressortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCompressorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCondenser_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCondenser_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifccondensertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCondenserType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenserType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcConstraint_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcConstraint" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + constraintgrade = self.ConstraintGrade + + assert (constraintgrade != IfcConstraintEnum.USERDEFINED) or ((constraintgrade == IfcConstraintEnum.USERDEFINED) and exists(self.UserDefinedGrade)) + + + + + +class IfcConstructionEquipmentResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionEquipmentResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionMaterialResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionMaterialResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionProductResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionProductResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + + + + + + + + + + + + + +class IfcController_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcController_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifccontrollertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcControllerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcControllerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcCooledBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCooledBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifccooledbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCooledBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCoolingTower_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoolingTower_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifccoolingtowertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoolingTowerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTowerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + +class IfcCovering_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCovering_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifccoveringtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoveringType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoveringType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCrewResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcCrewResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +def calc_IfcCsgPrimitive3D_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcCurtainWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCurtainWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifccurtainwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCurtainWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcCurve_Dim(self): + + return \ + IfcCurveDim(self) + + + + + + + + + + + + + +class IfcCurveStyle_MeasureOfWidth: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "MeasureOfWidth" + + @staticmethod + def __call__(self): + curvewidth = self.CurveWidth + + assert (not exists(curvewidth)) or ('ifc4x2.ifcpositivelengthmeasure' in typeof(curvewidth)) or (('ifc4x2.ifcdescriptivemeasure' in typeof(curvewidth)) and (curvewidth == 'bylayer')) + + + + +class IfcCurveStyle_IdentifiableCurveStyle: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "IdentifiableCurveStyle" + + @staticmethod + def __call__(self): + curvefont = self.CurveFont + curvewidth = self.CurveWidth + curvecolour = self.CurveColour + + assert exists(curvefont) or exists(curvewidth) or exists(curvecolour) + + + + + + + + + + + +class IfcCurveStyleFontPattern_VisibleLengthGreaterEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyleFontPattern" + RULE_NAME = "VisibleLengthGreaterEqualZero" + + @staticmethod + def __call__(self): + visiblesegmentlength = self.VisibleSegmentLength + + assert visiblesegmentlength >= 0. + + + + + + + + +class IfcDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDeepFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDeepFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcdeepfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + + + + +class IfcDerivedProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + parentprofile = self.ParentProfile + + assert self.ProfileType == parentprofile.ProfileType + + + + + +class IfcDerivedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof(elements) > 1) or ((sizeof(elements) == 1) and ((elements[1 - 1].Exponent) != 1)) + + + + +class IfcDerivedUnit_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + unittype = self.UnitType + + assert (unittype != IfcDerivedUnitEnum.USERDEFINED) or ((unittype == IfcDerivedUnitEnum.USERDEFINED) and exists(self.UserDefinedType)) + + + + +def calc_IfcDerivedUnit_Dimensions(self): + elements = self.Elements + return \ + IfcDeriveDimensionalExponents(elements) + + + + + + + + + + +class IfcDirection_MagnitudeGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcDirection" + RULE_NAME = "MagnitudeGreaterZero" + + @staticmethod + def __call__(self): + directionratios = self.DirectionRatios + + assert (sizeof([tmp for tmp in directionratios if tmp != 0.0])) > 0 + + + + +def calc_IfcDirection_Dim(self): + directionratios = self.DirectionRatios + return \ + hiindex(directionratios) + + + + +class IfcDiscreteAccessory_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDiscreteAccessory_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcdiscreteaccessorytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDiscreteAccessoryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessoryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcDistributionChamberElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionChamberElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcdistributionchamberelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionChamberElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDocumentReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDocumentReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + name = self.Name + referenceddocument = self.ReferencedDocument + + assert exists(name) ^ exists(referenceddocument) + + + + + +class IfcDoor_CorrectStyleAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectStyleAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcdoortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDoorLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcDoorLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + thresholddepth = self.ThresholdDepth + thresholdthickness = self.ThresholdThickness + + assert not exists(thresholddepth) and (not exists(thresholdthickness)) + + + + +class IfcDoorLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + transomthickness = self.TransomThickness + transomoffset = self.TransomOffset + + assert (exists(transomoffset) and exists(transomthickness)) ^ ((not exists(transomoffset)) and (not exists(transomthickness))) + + + + +class IfcDoorLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + casingthickness = self.CasingThickness + casingdepth = self.CasingDepth + + assert (exists(casingdepth) and exists(casingthickness)) ^ ((not exists(casingdepth)) and (not exists(casingthickness))) + + + + +class IfcDoorLiningProperties_WR35: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR35" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x2.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x2.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcDoorPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x2.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x2.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + + + + + + + +class IfcDoorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDoorTypeEnum.USERDEFINED) or ((predefinedtype == IfcDoorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDraughtingPreDefinedColour_PreDefinedColourNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedColour" + RULE_NAME = "PreDefinedColourNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['black','red','green','blue','yellow','magenta','cyan','white','bylayer'] + + + + + +class IfcDraughtingPreDefinedCurveFont_PreDefinedCurveFontNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedCurveFont" + RULE_NAME = "PreDefinedCurveFontNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['continuous','chain','chaindoubledash','dashed','dotted','bylayer'] + + + + + +class IfcDuctFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcductfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcductsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSilencer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSilencer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcductsilencertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSilencerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcEdgeLoop_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + edgelist = self.EdgeList + ne = self.Ne + + assert (edgelist[1 - 1].EdgeStart) == (edgelist[ne - 1].EdgeEnd) + + + + +class IfcEdgeLoop_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcLoopHeadToTail(self) + + + + +def calc_IfcEdgeLoop_Ne(self): + edgelist = self.EdgeList + return \ + sizeof(edgelist) + + + + +class IfcElectricAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcelectricappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcelectricdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowStorageDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowStorageDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcelectricflowstoragedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowStorageDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricGenerator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricGenerator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcelectricgeneratortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricGeneratorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGeneratorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricMotor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricMotor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcelectricmotortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricMotorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricTimeControl_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricTimeControl_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcelectrictimecontroltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricTimeControlType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControlType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcElementAssembly_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElementAssembly_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcelementassemblytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElementAssemblyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssemblyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcElementQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcElementQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + quantities = self.Quantities + + assert IfcUniqueQuantityNames(quantities) + + + + + + + + + + + + + + + + + + + + + + + +class IfcEngine_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEngine_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcenginetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEngineType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngineType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporativeCooler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporativeCooler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcevaporativecoolertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporativeCoolerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCoolerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcevaporatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvent_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvent_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (not exists(eventtriggertype)) or (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + +class IfcEventType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + +class IfcEventType_CorrectEventTriggerType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectEventTriggerType" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + + + + +class IfcExternalReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcExternalReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + location = self.Location + identification = self.Identification + name = self.Name + + assert exists(identification) or exists(location) or exists(name) + + + + + + + + + + + + + + + + + + + + + + + +class IfcExtrudedAreaSolid_ValidExtrusionDirection: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolid" + RULE_NAME = "ValidExtrusionDirection" + + @staticmethod + def __call__(self): + + + assert IfcDotProduct(IfcDirection(DirectionRatios=[0.0,0.0,1.0]),self.ExtrudedDirection) != 0.0 + + + + + +class IfcExtrudedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + +class IfcFace_HasOuterBound: + SCOPE = "entity" + TYPE_NAME = "IfcFace" + RULE_NAME = "HasOuterBound" + + @staticmethod + def __call__(self): + bounds = self.Bounds + + assert (sizeof([temp for temp in bounds if 'ifc4x2.ifcfaceouterbound' in typeof(temp)])) <= 1 + + + + + +def calc_IfcFaceBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFan_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcfantype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFanType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFanType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcFeatureElementSubtraction_HasNoSubtraction: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "HasNoSubtraction" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasOpenings) == 0 + + + + +class IfcFeatureElementSubtraction_IsNotFilling: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "IsNotFilling" + + @staticmethod + def __call__(self): + + + assert sizeof(self.FillsVoids) == 0 + + + + + +class IfcFillAreaStyle_MaxOneColour: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneColour" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x2.ifccolour' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_MaxOneExtHatchStyle: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneExtHatchStyle" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x2.ifcexternallydefinedhatchstyle' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_ConsistentHatchStyleDef: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "ConsistentHatchStyleDef" + + @staticmethod + def __call__(self): + + + assert IfcCorrectFillAreaStyle(self.FillStyles) + + + + + +class IfcFillAreaStyleHatching_PatternStart2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "PatternStart2D" + + @staticmethod + def __call__(self): + patternstart = self.PatternStart + + assert (not exists(patternstart)) or (patternstart.Dim == 2) + + + + +class IfcFillAreaStyleHatching_RefHatchLine2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "RefHatchLine2D" + + @staticmethod + def __call__(self): + pointofreferencehatchline = self.PointOfReferenceHatchLine + + assert (not exists(pointofreferencehatchline)) or (pointofreferencehatchline.Dim == 2) + + + + + + + + +class IfcFilter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFilter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcfiltertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFilterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFireSuppressionTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFireSuppressionTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcfiresuppressionterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFireSuppressionTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFixedReferenceSweptAreaSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcFixedReferenceSweptAreaSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x2.ifcconic','ifc4x2.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + + + + + + + + + + + + + +class IfcFlowInstrument_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowInstrument_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcflowinstrumenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowInstrumentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrumentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFlowMeter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowMeter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcflowmetertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowMeterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFooting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFooting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcfootingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFootingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFootingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcFurniture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFurniture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcfurnituretype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFurnitureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurnitureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeographicElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcGeographicElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcgeographicelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcGeographicElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeometricCurveSet_NoSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricCurveSet" + RULE_NAME = "NoSurfaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Elements if 'ifc4x2.ifcsurface' in typeof(temp)])) == 0 + + + + + +class IfcGeometricRepresentationContext_North2D: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationContext" + RULE_NAME = "North2D" + + @staticmethod + def __call__(self): + truenorth = self.TrueNorth + + assert (not exists(truenorth)) or (hiindex(truenorth.DirectionRatios) == 2) + + + + + + + + +class IfcGeometricRepresentationSubContext_ParentNoSub: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "ParentNoSub" + + @staticmethod + def __call__(self): + parentcontext = self.ParentContext + + assert not 'ifc4x2.ifcgeometricrepresentationsubcontext' in typeof(parentcontext) + + + + +class IfcGeometricRepresentationSubContext_UserTargetProvided: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "UserTargetProvided" + + @staticmethod + def __call__(self): + targetview = self.TargetView + userdefinedtargetview = self.UserDefinedTargetView + + assert (targetview != IfcGeometricProjectionEnum.USERDEFINED) or ((targetview == IfcGeometricProjectionEnum.USERDEFINED) and exists(userdefinedtargetview)) + + + + +class IfcGeometricRepresentationSubContext_NoCoordOperation: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "NoCoordOperation" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasCoordinateOperation) == 0 + + + + +def calc_IfcGeometricRepresentationSubContext_WorldCoordinateSystem(self): + parentcontext = self.ParentContext + return \ + parentcontext.WorldCoordinateSystem + + + +def calc_IfcGeometricRepresentationSubContext_CoordinateSpaceDimension(self): + parentcontext = self.ParentContext + return \ + parentcontext.CoordinateSpaceDimension + + + +def calc_IfcGeometricRepresentationSubContext_TrueNorth(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.TrueNorth,IfcConvertDirectionInto2D(self.WorldCoordinateSystem.P[2 - 1])) + + + +def calc_IfcGeometricRepresentationSubContext_Precision(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.Precision,1) + + + + +class IfcGeometricSet_ConsistentDim: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricSet" + RULE_NAME = "ConsistentDim" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof([temp for temp in elements if temp.Dim != (elements[1 - 1].Dim)])) == 0 + + + + +def calc_IfcGeometricSet_Dim(self): + elements = self.Elements + return \ + elements[1 - 1].Dim + + + + + + + +class IfcGridAxis_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + axiscurve = self.AxisCurve + + assert axiscurve.Dim == 2 + + + + +class IfcGridAxis_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + partofw = self.PartOfW + partofv = self.PartOfV + partofu = self.PartOfU + + assert (sizeof(partofu) == 1) ^ (sizeof(partofv) == 1) ^ (sizeof(partofw) == 1) + + + + + + + + + + + +def calc_IfcHalfSpaceSolid_Dim(self): + + return \ + 3 + + + + +class IfcHeatExchanger_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHeatExchanger_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcheatexchangertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHeatExchangerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchangerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcHumidifier_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHumidifier_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifchumidifiertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHumidifierType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifierType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + flangethickness = self.FlangeThickness + + assert (2. * flangethickness) < overalldepth + + + + +class IfcIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + webthickness = self.WebThickness + + assert webthickness < overallwidth + + + + +class IfcIShapeProfileDef_ValidFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFilletRadius" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + overalldepth = self.OverallDepth + webthickness = self.WebThickness + flangethickness = self.FlangeThickness + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or ((filletradius <= ((overallwidth - webthickness) / 2.)) and (filletradius <= ((overalldepth - (2. * flangethickness)) / 2.))) + + + + + + + + + + + +class IfcIndexedPolyCurve_Consecutive: + SCOPE = "entity" + TYPE_NAME = "IfcIndexedPolyCurve" + RULE_NAME = "Consecutive" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (sizeof(segments) == 0) or IfcConsecutiveSegments(segments) + + + + + + + + + + + + + + + + + +class IfcInterceptor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcInterceptor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcinterceptortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcInterceptorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIntersectionCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + +class IfcIntersectionCurve_DistinctSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "DistinctSurfaces" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) != (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + + + + + + + + + + + +class IfcJunctionBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcJunctionBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcjunctionboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcJunctionBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcLShapeProfileDef_ValidThickness: + SCOPE = "entity" + TYPE_NAME = "IfcLShapeProfileDef" + RULE_NAME = "ValidThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + thickness = self.Thickness + + assert (thickness < depth) and ((not exists(width)) or (thickness < width)) + + + + + +class IfcLaborResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcLaborResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +class IfcLamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifclamptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcLightFixture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLightFixture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifclightfixturetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLightFixtureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixtureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcLine_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcLine" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + pnt = self.Pnt + dir = self.Dir + + assert dir.Dim == pnt.Dim + + + + + + + + + + + + + + +class IfcLocalPlacement_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcLocalPlacement" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + placementrelto = self.PlacementRelTo + relativeplacement = self.RelativePlacement + + assert IfcCorrectLocalPlacement(relativeplacement,placementrelto) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMaterialDefinitionRepresentation_OnlyStyledRepresentations: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialDefinitionRepresentation" + RULE_NAME = "OnlyStyledRepresentations" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x2.ifcstyledrepresentation' in typeof(temp)])) == 0 + + + + + +class IfcMaterialLayer_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialLayer" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + +def calc_IfcMaterialLayerSet_TotalThickness(self): + + return \ + IfcMlsTotalThickness(self) + + + + + + + + + + + + + +class IfcMaterialProfile_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialProfile" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMechanicalFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMechanicalFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcmechanicalfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMechanicalFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMedicalDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMedicalDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcmedicaldevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMedicalDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMember_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMember_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcmembertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMemberStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcMemberStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x2.ifcrelassociates.relatedobjects') if ('ifc4x2.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x2.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcMemberType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMemberType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcMirroredProfileDef_Operator(self): + + return \ + IfcCartesianTransformationOperator2D(Axis1=IfcDirection(DirectionRatios=[-1.,0.]), Axis2=IfcDirection(DirectionRatios=[0.,1.]), LocalOrigin=IfcCartesianPoint(Coordinates=[0.,0.]), Scale=1.) + + + + + + + +class IfcMotorConnection_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMotorConnection_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcmotorconnectiontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMotorConnectionType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnectionType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcNamedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcNamedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert IfcCorrectDimensions(self.UnitType,self.Dimensions) + + + + + +class IfcObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + isdefinedby = self.IsDefinedBy + + assert (sizeof(isdefinedby) == 0) or IfcUniqueDefinitionNames(isdefinedby) + + + + + + + + + + + +class IfcObjective_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcObjective" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + objectivequalifier = self.ObjectiveQualifier + + assert (objectivequalifier != IfcObjectiveEnum.USERDEFINED) or ((objectivequalifier == IfcObjectiveEnum.USERDEFINED) and exists(self.UserDefinedQualifier)) + + + + + +class IfcOccupant_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcOccupant" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not predefinedtype == IfcOccupantTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcOffsetCurve2D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve2D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 2 + + + + + +class IfcOffsetCurve3D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve3D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 3 + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcOrientedEdge_EdgeElementNotOriented: + SCOPE = "entity" + TYPE_NAME = "IfcOrientedEdge" + RULE_NAME = "EdgeElementNotOriented" + + @staticmethod + def __call__(self): + edgeelement = self.EdgeElement + + assert not 'ifc4x2.ifcorientededge' in typeof(edgeelement) + + + + +def calc_IfcOrientedEdge_EdgeStart(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeStart,edgeelement.EdgeEnd) + + + +def calc_IfcOrientedEdge_EdgeEnd(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeEnd,edgeelement.EdgeStart) + + + + + + + +class IfcOutlet_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcOutlet_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcoutlettype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcOutletType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutletType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcOwnerHistory_CorrectChangeAction: + SCOPE = "entity" + TYPE_NAME = "IfcOwnerHistory" + RULE_NAME = "CorrectChangeAction" + + @staticmethod + def __call__(self): + changeaction = self.ChangeAction + lastmodifieddate = self.LastModifiedDate + + assert exists(lastmodifieddate) or ((not exists(lastmodifieddate)) and (not exists(changeaction))) or ((not exists(lastmodifieddate)) and exists(changeaction) and ((changeaction == IfcChangeActionEnum.NOTDEFINED) or (changeaction == IfcChangeActionEnum.NOCHANGE))) + + + + + + + + +class IfcPath_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcPath" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcPathHeadToTail(self) + + + + + +class IfcPcurve_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcPcurve" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + referencecurve = self.ReferenceCurve + + assert referencecurve.Dim == 2 + + + + + + + + + + + + + + +class IfcPerson_IdentifiablePerson: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "IdentifiablePerson" + + @staticmethod + def __call__(self): + identification = self.Identification + familyname = self.FamilyName + givenname = self.GivenName + + assert exists(identification) or exists(familyname) or exists(givenname) + + + + +class IfcPerson_ValidSetOfNames: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "ValidSetOfNames" + + @staticmethod + def __call__(self): + familyname = self.FamilyName + givenname = self.GivenName + middlenames = self.MiddleNames + + assert (not exists(middlenames)) or exists(familyname) or exists(givenname) + + + + + + + + +class IfcPhysicalComplexQuantity_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert (sizeof([temp for temp in hasquantities if self == temp])) == 0 + + + + +class IfcPhysicalComplexQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert IfcUniqueQuantityNames(hasquantities) + + + + + + + + + + + +class IfcPile_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPile_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcpiletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPileType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPileType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcpipefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcpipesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPixelTexture_MinPixelInS: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInS" + + @staticmethod + def __call__(self): + width = self.Width + + assert width >= 1 + + + + +class IfcPixelTexture_MinPixelInT: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInT" + + @staticmethod + def __call__(self): + height = self.Height + + assert height >= 1 + + + + +class IfcPixelTexture_NumberOfColours: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "NumberOfColours" + + @staticmethod + def __call__(self): + colourcomponents = self.ColourComponents + + assert 1 <= colourcomponents <= 4 + + + + +class IfcPixelTexture_SizeOfPixelList: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "SizeOfPixelList" + + @staticmethod + def __call__(self): + width = self.Width + height = self.Height + pixel = self.Pixel + + assert sizeof(pixel) == (width * height) + + + + +class IfcPixelTexture_PixelAsByteAndSameLength: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "PixelAsByteAndSameLength" + + @staticmethod + def __call__(self): + pixel = self.Pixel + + assert (sizeof([temp for temp in pixel if ((blength(temp) % 8) == 0) and (blength(temp) == (blength(pixel[1 - 1])))])) == sizeof(pixel) + + + + + +def calc_IfcPlacement_Dim(self): + location = self.Location + return \ + location.Dim + + + + + + + + + + + + + +class IfcPlate_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPlate_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcplatetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPlateStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcPlateStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x2.ifcrelassociates.relatedobjects') if ('ifc4x2.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x2.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcPlateType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlateType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcPointOnCurve_Dim(self): + basiscurve = self.BasisCurve + return \ + basiscurve.Dim + + + + +def calc_IfcPointOnSurface_Dim(self): + basissurface = self.BasisSurface + return \ + basissurface.Dim + + + + +class IfcPolyLoop_AllPointsSameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyLoop" + RULE_NAME = "AllPointsSameDim" + + @staticmethod + def __call__(self): + polygon = self.Polygon + + assert (sizeof([temp for temp in polygon if temp.Dim != (polygon[1 - 1].Dim)])) == 0 + + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryDim" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert polygonalboundary.Dim == 2 + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryType: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryType" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert (sizeof(typeof(polygonalboundary) * ['ifc4x2.ifcpolyline','ifc4x2.ifccompositecurve'])) == 1 + + + + + + + + +class IfcPolyline_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyline" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + points = self.Points + + assert (sizeof([temp for temp in points if temp.Dim != (points[1 - 1].Dim)])) == 0 + + + + + + + + +class IfcPositioningElement_HasPlacement: + SCOPE = "entity" + TYPE_NAME = "IfcPositioningElement" + RULE_NAME = "HasPlacement" + + @staticmethod + def __call__(self): + + + assert exists(self.ObjectPlacement) + + + + + +class IfcPostalAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPostalAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + internallocation = self.InternalLocation + addresslines = self.AddressLines + postalbox = self.PostalBox + town = self.Town + region = self.Region + postalcode = self.PostalCode + country = self.Country + + assert exists(internallocation) or exists(addresslines) or exists(postalbox) or exists(postalcode) or exists(town) or exists(region) or exists(country) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPresentationLayerAssignment_ApplicableItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerAssignment" + RULE_NAME = "ApplicableItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x2.ifcshaperepresentation','ifc4x2.ifcgeometricrepresentationitem','ifc4x2.ifcmappeditem'])) == 1])) == sizeof(assigneditems) + + + + + +class IfcPresentationLayerWithStyle_ApplicableOnlyToItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerWithStyle" + RULE_NAME = "ApplicableOnlyToItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x2.ifcgeometricrepresentationitem','ifc4x2.ifcmappeditem'])) >= 1])) == sizeof(assigneditems) + + + + + + + + + + + +class IfcProcedure_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProcedure_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcProcedureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + + + + +class IfcProduct_PlacementForShapeRepresentation: + SCOPE = "entity" + TYPE_NAME = "IfcProduct" + RULE_NAME = "PlacementForShapeRepresentation" + + @staticmethod + def __call__(self): + objectplacement = self.ObjectPlacement + representation = self.Representation + + assert (exists(representation) and exists(objectplacement)) or (exists(representation) and ((sizeof([temp for temp in representation.Representations if 'ifc4x2.ifcshaperepresentation' in typeof(temp)])) == 0)) or (not exists(representation)) + + + + + +class IfcProductDefinitionShape_OnlyShapeModel: + SCOPE = "entity" + TYPE_NAME = "IfcProductDefinitionShape" + RULE_NAME = "OnlyShapeModel" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x2.ifcshapemodel' in typeof(temp)])) == 0 + + + + + + + + + + + + + + +class IfcProject_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProject_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert (not exists(self.RepresentationContexts)) or ((sizeof([temp for temp in self.RepresentationContexts if 'ifc4x2.ifcgeometricrepresentationsubcontext' in typeof(temp)])) == 0) + + + + +class IfcProject_NoDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "NoDecomposition" + + @staticmethod + def __call__(self): + + + assert sizeof(self.Decomposes) == 0 + + + + + + + + + + + +class IfcProjectedCRS_IsLengthUnit: + SCOPE = "entity" + TYPE_NAME = "IfcProjectedCRS" + RULE_NAME = "IsLengthUnit" + + @staticmethod + def __call__(self): + mapunit = self.MapUnit + + assert (not exists(mapunit)) or (mapunit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + + + + + + + + + + + +class IfcPropertyBoundedValue_SameUnitUpperLower: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperLower" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + lowerboundvalue = self.LowerBoundValue + + assert (not exists(upperboundvalue)) or (not exists(lowerboundvalue)) or (typeof(upperboundvalue) == typeof(lowerboundvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitUpperSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperSet" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(upperboundvalue)) or (not exists(setpointvalue)) or (typeof(upperboundvalue) == typeof(setpointvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitLowerSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitLowerSet" + + @staticmethod + def __call__(self): + lowerboundvalue = self.LowerBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(lowerboundvalue)) or (not exists(setpointvalue)) or (typeof(lowerboundvalue) == typeof(setpointvalue)) + + + + + + + + +class IfcPropertyDependencyRelationship_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyDependencyRelationship" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + dependingproperty = self.DependingProperty + dependantproperty = self.DependantProperty + + assert dependingproperty != dependantproperty + + + + + +class IfcPropertyEnumeratedValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeratedValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + enumerationvalues = self.EnumerationValues + enumerationreference = self.EnumerationReference + + assert (not exists(enumerationreference)) or (not exists(enumerationvalues)) or ((sizeof([temp for temp in enumerationvalues if temp in enumerationreference.EnumerationValues])) == sizeof(enumerationvalues)) + + + + + +class IfcPropertyEnumeration_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeration" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.EnumerationValues if not (typeof(self.EnumerationValues[1 - 1])) == typeof(temp)])) == 0 + + + + + +class IfcPropertyListValue_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyListValue" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.ListValues if not (typeof(self.ListValues[1 - 1])) == typeof(temp)])) == 0 + + + + + + + + +class IfcPropertySet_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySet_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + + + + +class IfcPropertySetTemplate_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySetTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + + + + + +class IfcPropertyTableValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + definedvalues = self.DefinedValues + + assert ((not exists(definingvalues)) and (not exists(definedvalues))) or (sizeof(definingvalues) == sizeof(definedvalues)) + + + + +class IfcPropertyTableValue_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + + assert (not exists(definingvalues)) or ((sizeof([temp for temp in self.DefiningValues if typeof(temp) != (typeof(self.DefiningValues[1 - 1]))])) == 0) + + + + +class IfcPropertyTableValue_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + definedvalues = self.DefinedValues + + assert (not exists(definedvalues)) or ((sizeof([temp for temp in self.DefinedValues if typeof(temp) != (typeof(self.DefinedValues[1 - 1]))])) == 0) + + + + + + + + + + + +class IfcProtectiveDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcprotectivedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcprotectivedevicetrippingunittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProtectiveDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProxy_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcProxy" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcPump_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPump_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcpumptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPumpType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPumpType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcQuantityArea_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.AREAUNIT) + + + + +class IfcQuantityArea_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + areavalue = self.AreaValue + + assert areavalue >= 0. + + + + + +class IfcQuantityCount_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityCount" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + countvalue = self.CountValue + + assert countvalue >= 0. + + + + + +class IfcQuantityLength_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + +class IfcQuantityLength_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + lengthvalue = self.LengthValue + + assert lengthvalue >= 0. + + + + + + + + +class IfcQuantityTime_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.TIMEUNIT) + + + + +class IfcQuantityTime_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + timevalue = self.TimeValue + + assert timevalue >= 0. + + + + + +class IfcQuantityVolume_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.VOLUMEUNIT) + + + + +class IfcQuantityVolume_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + volumevalue = self.VolumeValue + + assert volumevalue >= 0. + + + + + +class IfcQuantityWeight_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.MASSUNIT) + + + + +class IfcQuantityWeight_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + weightvalue = self.WeightValue + + assert weightvalue >= 0. + + + + + +class IfcRailing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRailing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcrailingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcramptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRampFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcrampflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRationalBSplineCurveWithKnots_SameNumOfWeightsAndPoints: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "SameNumOfWeightsAndPoints" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert sizeof(weightsdata) == sizeof(self.ControlPointsList) + + + + +class IfcRationalBSplineCurveWithKnots_WeightsGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "WeightsGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcCurveWeightsPositive(self) + + + + +def calc_IfcRationalBSplineCurveWithKnots_Weights(self): + weightsdata = self.WeightsData + return \ + IfcListToArray(weightsdata,0,self.UpperIndexOnControlPoints) + + + + +class IfcRationalBSplineSurfaceWithKnots_CorrespondingWeightsDataLists: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingWeightsDataLists" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert (sizeof(weightsdata) == sizeof(self.ControlPointsList)) and ((sizeof(weightsdata[1 - 1])) == (sizeof(self.ControlPointsList[1 - 1]))) + + + + +class IfcRationalBSplineSurfaceWithKnots_WeightValuesGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "WeightValuesGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcSurfaceWeightsPositive(self) + + + + +def calc_IfcRationalBSplineSurfaceWithKnots_Weights(self): + uupper = self.UUpper + vupper = self.VUpper + weightsdata = self.WeightsData + return \ + IfcMakeArrayOfArray(weightsdata,0,uupper,0,vupper) + + + + +class IfcRectangleHollowProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert (wallthickness < (self.XDim / 2.)) and (wallthickness < (self.YDim / 2.)) + + + + +class IfcRectangleHollowProfileDef_ValidInnerRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidInnerRadius" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + innerfilletradius = self.InnerFilletRadius + + assert (not exists(innerfilletradius)) or ((innerfilletradius <= ((self.XDim / 2.) - wallthickness)) and (innerfilletradius <= ((self.YDim / 2.) - wallthickness))) + + + + +class IfcRectangleHollowProfileDef_ValidOuterRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidOuterRadius" + + @staticmethod + def __call__(self): + outerfilletradius = self.OuterFilletRadius + + assert (not exists(outerfilletradius)) or ((outerfilletradius <= (self.XDim / 2.)) and (outerfilletradius <= (self.YDim / 2.))) + + + + + + + + + + + +class IfcRectangularTrimmedSurface_U1AndU2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "U1AndU2Different" + + @staticmethod + def __call__(self): + u1 = self.U1 + u2 = self.U2 + + assert u1 != u2 + + + + +class IfcRectangularTrimmedSurface_V1AndV2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "V1AndV2Different" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + + assert v1 != v2 + + + + +class IfcRectangularTrimmedSurface_UsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "UsenseCompatible" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + u1 = self.U1 + u2 = self.U2 + usense = self.Usense + + assert (('ifc4x2.ifcelementarysurface' in typeof(basissurface)) and (not 'ifc4x2.ifcplane' in typeof(basissurface))) or ('ifc4x2.ifcsurfaceofrevolution' in typeof(basissurface)) or (usense == (u2 > u1)) + + + + +class IfcRectangularTrimmedSurface_VsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "VsenseCompatible" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + vsense = self.Vsense + + assert vsense == (v2 > v1) + + + + + + + + + + + + + + + + + + + + + + + +class IfcReinforcingBar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingBar_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcreinforcingbartype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingBarType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + +class IfcReinforcingBarType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + + + + + + + + +class IfcReinforcingMesh_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingMesh_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcreinforcingmeshtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingMeshType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + +class IfcReinforcingMeshType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + + +class IfcRelAggregates_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAggregates" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelAssigns_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssigns" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatedobjects = self.RelatedObjects + relatedobjectstype = self.RelatedObjectsType + + assert IfcCorrectObjectAssignment(relatedobjectstype,relatedobjects) + + + + + +class IfcRelAssignsToActor_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToActor" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingactor = self.RelatingActor + + assert (sizeof([temp for temp in self.RelatedObjects if relatingactor == temp])) == 0 + + + + + +class IfcRelAssignsToControl_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToControl" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontrol = self.RelatingControl + + assert (sizeof([temp for temp in self.RelatedObjects if relatingcontrol == temp])) == 0 + + + + + +class IfcRelAssignsToGroup_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToGroup" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatinggroup = self.RelatingGroup + + assert (sizeof([temp for temp in self.RelatedObjects if relatinggroup == temp])) == 0 + + + + + + + + +class IfcRelAssignsToProcess_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProcess" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + + assert (sizeof([temp for temp in self.RelatedObjects if relatingprocess == temp])) == 0 + + + + + +class IfcRelAssignsToProduct_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProduct" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingproduct = self.RelatingProduct + + assert (sizeof([temp for temp in self.RelatedObjects if relatingproduct == temp])) == 0 + + + + + +class IfcRelAssignsToResource_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToResource" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingresource = self.RelatingResource + + assert (sizeof([temp for temp in self.RelatedObjects if relatingresource == temp])) == 0 + + + + + + + + + + + + + + + + + + + + + + + +class IfcRelAssociatesMaterial_NoVoidElement: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "NoVoidElement" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if ('ifc4x2.ifcfeatureelementsubtraction' in typeof(temp)) or ('ifc4x2.ifcvirtualelement' in typeof(temp))])) == 0 + + + + +class IfcRelAssociatesMaterial_AllowedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "AllowedElements" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if (sizeof(typeof(temp) * ['ifc4x2.ifcelement','ifc4x2.ifcelementtype','ifc4x2.ifcwindowstyle','ifc4x2.ifcdoorstyle','ifc4x2.ifcstructuralmember','ifc4x2.ifcport'])) == 0])) == 0 + + + + + + + + +class IfcRelConnectsElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelConnectsPathElements_NormalizedRelatingPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatingPriorities" + + @staticmethod + def __call__(self): + relatingpriorities = self.RelatingPriorities + + assert (sizeof(relatingpriorities) == 0) or ((sizeof([temp for temp in relatingpriorities if 0 <= temp <= 100])) == sizeof(relatingpriorities)) + + + + +class IfcRelConnectsPathElements_NormalizedRelatedPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatedPriorities" + + @staticmethod + def __call__(self): + relatedpriorities = self.RelatedPriorities + + assert (sizeof(relatedpriorities) == 0) or ((sizeof([temp for temp in relatedpriorities if 0 <= temp <= 100])) == sizeof(relatedpriorities)) + + + + + + + + +class IfcRelConnectsPorts_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPorts" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingport = self.RelatingPort + relatedport = self.RelatedPort + + assert relatingport != relatedport + + + + + + + + + + + + + + + + + +class IfcRelContainedInSpatialStructure_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRelContainedInSpatialStructure" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if 'ifc4x2.ifcspatialstructureelement' in typeof(temp)])) == 0 + + + + + + + + + + + +class IfcRelDeclares_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelDeclares" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontext = self.RelatingContext + relateddefinitions = self.RelatedDefinitions + + assert (sizeof([temp for temp in relateddefinitions if relatingcontext == temp])) == 0 + + + + + + + + + + + + + + +class IfcRelDefinesByProperties_NoRelatedTypeObject: + SCOPE = "entity" + TYPE_NAME = "IfcRelDefinesByProperties" + RULE_NAME = "NoRelatedTypeObject" + + @staticmethod + def __call__(self): + + + assert (sizeof([types for types in self.RelatedObjects if 'ifc4x2.ifctypeobject' in typeof(types)])) == 0 + + + + + + + + + + + + + + + + + +class IfcRelInterferesElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelInterferesElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelNests_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelNests" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelPositions_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelPositions" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingpositioningelement = self.RelatingPositioningElement + relatedproducts = self.RelatedProducts + + assert (sizeof([temp for temp in relatedproducts if relatingpositioningelement == temp])) == 0 + + + + + + + + +class IfcRelReferencedInSpatialStructure_AllowedRelatedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelReferencedInSpatialStructure" + RULE_NAME = "AllowedRelatedElements" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if ('ifc4x2.ifcspatialstructureelement' in typeof(temp)) and (not 'ifc4x2.ifcspace' in typeof(temp))])) == 0 + + + + + +class IfcRelSequence_AvoidInconsistentSequence: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "AvoidInconsistentSequence" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + relatedprocess = self.RelatedProcess + + assert relatingprocess != relatedprocess + + + + +class IfcRelSequence_CorrectSequenceType: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "CorrectSequenceType" + + @staticmethod + def __call__(self): + sequencetype = self.SequenceType + userdefinedsequencetype = self.UserDefinedSequenceType + + assert (sequencetype != IfcSequenceEnum.USERDEFINED) or ((sequencetype == IfcSequenceEnum.USERDEFINED) and exists(userdefinedsequencetype)) + + + + + + + + +class IfcRelSpaceBoundary_CorrectPhysOrVirt: + SCOPE = "entity" + TYPE_NAME = "IfcRelSpaceBoundary" + RULE_NAME = "CorrectPhysOrVirt" + + @staticmethod + def __call__(self): + relatedbuildingelement = self.RelatedBuildingElement + physicalorvirtualboundary = self.PhysicalOrVirtualBoundary + + assert ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Physical) and (not 'ifc4x2.ifcvirtualelement' in typeof(relatedbuildingelement))) or ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Virtual) and (('ifc4x2.ifcvirtualelement' in typeof(relatedbuildingelement)) or ('ifc4x2.ifcopeningelement' in typeof(relatedbuildingelement)))) or (physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.NotDefined) + + + + + + + + + + + + + + + + + +class IfcReparametrisedCompositeCurveSegment_PositiveLengthParameter: + SCOPE = "entity" + TYPE_NAME = "IfcReparametrisedCompositeCurveSegment" + RULE_NAME = "PositiveLengthParameter" + + @staticmethod + def __call__(self): + paramlength = self.ParamLength + + assert paramlength > 0.0 + + + + + + + + + + + + + + +class IfcRepresentationMap_ApplicableMappedRepr: + SCOPE = "entity" + TYPE_NAME = "IfcRepresentationMap" + RULE_NAME = "ApplicableMappedRepr" + + @staticmethod + def __call__(self): + mappedrepresentation = self.MappedRepresentation + + assert 'ifc4x2.ifcshapemodel' in typeof(mappedrepresentation) + + + + + + + + + + + + + + + + + + + + +class IfcRevolvedAreaSolid_AxisStartInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisStartInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Location.Coordinates[3 - 1]) == 0.0 + + + + +class IfcRevolvedAreaSolid_AxisDirectionInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisDirectionInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Z.DirectionRatios[3 - 1]) == 0.0 + + + + +def calc_IfcRevolvedAreaSolid_AxisLine(self): + axis = self.Axis + return \ + IfcLine(Pnt=axis.Location, Dir=IfcVector(Orientation=axis.Z, Magnitude=1.0)) + + + + +class IfcRevolvedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + + + + + + + +class IfcRoof_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRoof_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcrooftype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRoofType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoofType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcRoundedRectangleProfileDef_ValidRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRoundedRectangleProfileDef" + RULE_NAME = "ValidRadius" + + @staticmethod + def __call__(self): + roundingradius = self.RoundingRadius + + assert (roundingradius <= (self.XDim / 2.)) and (roundingradius <= (self.YDim / 2.)) + + + + + +def calc_IfcSIUnit_Dimensions(self): + + return \ + IfcDimensionsForSiUnit(self.Name) + + + + +class IfcSanitaryTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSanitaryTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcsanitaryterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSanitaryTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSeamCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + +class IfcSeamCurve_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) == (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + + + + + + + + +class IfcSectionedSolid_DirectrixIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "DirectrixIs3D" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSectionedSolid_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSolid_SectionsSameType: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "SectionsSameType" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (typeof(crosssections[1 - 1])) != typeof(temp)])) == 0 + + + + + +class IfcSectionedSolidHorizontal_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSolidHorizontal_NoLongitudinalOffsets: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "NoLongitudinalOffsets" + + @staticmethod + def __call__(self): + crosssectionpositions = self.CrossSectionPositions + + assert (sizeof([temp for temp in crosssectionpositions if exists(temp.OffsetLongitudinal)])) == 0 + + + + + +class IfcSectionedSpine_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSpine_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSpine_SpineCurveDim: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "SpineCurveDim" + + @staticmethod + def __call__(self): + spinecurve = self.SpineCurve + + assert spinecurve.Dim == 3 + + + + +def calc_IfcSectionedSpine_Dim(self): + + return \ + 3 + + + + +class IfcSensor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSensor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcsensortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSensorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcShadingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcShadingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcshadingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcShadingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcShapeModel_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcShapeModel" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + ofshapeaspect = self.OfShapeAspect + + assert (sizeof(self.OfProductRepresentation) == 1) ^ (sizeof(self.RepresentationMap) == 1) ^ (sizeof(ofshapeaspect) == 1) + + + + + +class IfcShapeRepresentation_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert 'ifc4x2.ifcgeometricrepresentationcontext' in typeof(self.ContextOfItems) + + + + +class IfcShapeRepresentation_NoTopologicalItem: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "NoTopologicalItem" + + @staticmethod + def __call__(self): + items = self.Items + + assert (sizeof([temp for temp in items if ('ifc4x2.ifctopologicalrepresentationitem' in typeof(temp)) and (not (sizeof(['ifc4x2.ifcvertexpoint','ifc4x2.ifcedgecurve','ifc4x2.ifcfacesurface'] * typeof(temp))) == 1)])) == 0 + + + + +class IfcShapeRepresentation_HasRepresentationType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationType" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcShapeRepresentation_HasRepresentationIdentifier: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationIdentifier" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationIdentifier) + + + + +class IfcShapeRepresentation_CorrectItemsForType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectItemsForType" + + @staticmethod + def __call__(self): + + + assert IfcShapeRepresentationTypes(self.RepresentationType,self.Items) + + + + + +def calc_IfcShellBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + + + + + + + + + + +class IfcSlab_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSlab_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcslabtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSlabElementedCase_HasDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcSlabElementedCase" + RULE_NAME = "HasDecomposition" + + @staticmethod + def __call__(self): + + + assert hiindex(self.IsDecomposedBy) > 0 + + + + + +class IfcSlabStandardCase_HasMaterialLayerSetusage: + SCOPE = "entity" + TYPE_NAME = "IfcSlabStandardCase" + RULE_NAME = "HasMaterialLayerSetusage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x2.ifcrelassociates.relatedobjects') if ('ifc4x2.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x2.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcSlabType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlabType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSolarDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSolarDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcsolardevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSolarDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcSolidModel_Dim(self): + + return \ + 3 + + + + +class IfcSpace_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpace_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcspacetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeater_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpaceHeater_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcspaceheatertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeaterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeaterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSpaceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcSpatialStructureElement_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialStructureElement" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + + + assert (hiindex(self.Decomposes) == 1) and ('ifc4x2.ifcrelaggregates' in (typeof(self.Decomposes[1 - 1]))) and (('ifc4x2.ifcproject' in (typeof(self.Decomposes[1 - 1].RelatingObject))) or ('ifc4x2.ifcspatialstructureelement' in (typeof(self.Decomposes[1 - 1].RelatingObject)))) + + + + + + + + +class IfcSpatialZone_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpatialZone_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcspatialzonetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpatialZoneType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZoneType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcStackTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStackTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcstackterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStackTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStair_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStair_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcstairtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStairFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcstairflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStairType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcStructuralAnalysisModel_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralAnalysisModel" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAnalysisModelTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + + + + +class IfcStructuralCurveAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralCurveAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveAction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert predefinedtype != IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + + + + + + + +class IfcStructuralCurveMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralCurveReaction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveReaction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.SINUS) and (predefinedtype != IfcStructuralCurveActivityTypeEnum.PARABOLA) + + + + + + + + +class IfcStructuralLinearAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x2.ifcstructuralloadlinearforce','ifc4x2.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + +class IfcStructuralLinearAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralCurveActivityTypeEnum.CONST + + + + + + + + +class IfcStructuralLoadCase_IsLoadCasePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadCase" + RULE_NAME = "IsLoadCasePredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcLoadGroupTypeEnum.LOAD_CASE + + + + + +class IfcStructuralLoadConfiguration_ValidListSize: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadConfiguration" + RULE_NAME = "ValidListSize" + + @staticmethod + def __call__(self): + values = self.Values + locations = self.Locations + + assert (not exists(locations)) or (sizeof(locations) == sizeof(values)) + + + + + +class IfcStructuralLoadGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + actiontype = self.ActionType + actionsource = self.ActionSource + + assert ((predefinedtype != IfcLoadGroupTypeEnum.USERDEFINED) and (actiontype != IfcActionTypeEnum.USERDEFINED) and (actionsource != IfcActionSourceTypeEnum.USERDEFINED)) or exists(self.ObjectType) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcStructuralPlanarAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x2.ifcstructuralloadplanarforce','ifc4x2.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + +class IfcStructuralPlanarAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralSurfaceActivityTypeEnum.CONST + + + + + +class IfcStructuralPointAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x2.ifcstructuralloadsingleforce','ifc4x2.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralPointReaction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointReaction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x2.ifcstructuralloadsingleforce','ifc4x2.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralResultGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralResultGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + theorytype = self.TheoryType + + assert (theorytype != IfcAnalysisTheoryTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcStructuralSurfaceAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralSurfaceAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceReaction_HasPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceReaction" + RULE_NAME = "HasPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStyledItem_ApplicableItem: + SCOPE = "entity" + TYPE_NAME = "IfcStyledItem" + RULE_NAME = "ApplicableItem" + + @staticmethod + def __call__(self): + item = self.Item + + assert not 'ifc4x2.ifcstyleditem' in typeof(item) + + + + + +class IfcStyledRepresentation_OnlyStyledItems: + SCOPE = "entity" + TYPE_NAME = "IfcStyledRepresentation" + RULE_NAME = "OnlyStyledItems" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x2.ifcstyleditem' in typeof(temp)])) == 0 + + + + + +class IfcSubContractResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcSubContractResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +def calc_IfcSurface_Dim(self): + + return \ + 3 + + + + +class IfcSurfaceCurve_CurveIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIs3D" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert curve3d.Dim == 3 + + + + +class IfcSurfaceCurve_CurveIsNotPcurve: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIsNotPcurve" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert not 'ifc4x2.ifcpcurve' in typeof(curve3d) + + + + +def calc_IfcSurfaceCurve_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + +class IfcSurfaceCurveSweptAreaSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurveSweptAreaSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x2.ifcconic','ifc4x2.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + +class IfcSurfaceFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSurfaceFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcSurfaceOfLinearExtrusion_DepthGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceOfLinearExtrusion" + RULE_NAME = "DepthGreaterZero" + + @staticmethod + def __call__(self): + depth = self.Depth + + assert depth > 0. + + + + +def calc_IfcSurfaceOfLinearExtrusion_ExtrusionAxis(self): + extrudeddirection = self.ExtrudedDirection + depth = self.Depth + return \ + IfcVector(Orientation=extrudeddirection, Magnitude=depth) + + + + +def calc_IfcSurfaceOfRevolution_AxisLine(self): + axisposition = self.AxisPosition + return \ + IfcLine(Pnt=axisposition.Location, Dir=IfcVector(Orientation=axisposition.Z, Magnitude=1.0)) + + + + +class IfcSurfaceReinforcementArea_SurfaceAndOrShearAreaSpecified: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "SurfaceAndOrShearAreaSpecified" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + surfacereinforcement2 = self.SurfaceReinforcement2 + shearreinforcement = self.ShearReinforcement + + assert exists(surfacereinforcement1) or exists(surfacereinforcement2) or exists(shearreinforcement) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea1: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea1" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + + assert (not exists(surfacereinforcement1)) or (((surfacereinforcement1[1 - 1]) >= 0.) and ((surfacereinforcement1[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement1) == 1) or ((surfacereinforcement1[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea2: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea2" + + @staticmethod + def __call__(self): + surfacereinforcement2 = self.SurfaceReinforcement2 + + assert (not exists(surfacereinforcement2)) or (((surfacereinforcement2[1 - 1]) >= 0.) and ((surfacereinforcement2[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement2) == 1) or ((surfacereinforcement2[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea3: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea3" + + @staticmethod + def __call__(self): + shearreinforcement = self.ShearReinforcement + + assert (not exists(shearreinforcement)) or (shearreinforcement >= 0.) + + + + + +class IfcSurfaceStyle_MaxOneShading: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneShading" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x2.ifcsurfacestyleshading' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneLighting: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneLighting" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x2.ifcsurfacestylelighting' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneRefraction: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneRefraction" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x2.ifcsurfacestylerefraction' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneTextures: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneTextures" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x2.ifcsurfacestylewithtextures' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneExtDefined: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneExtDefined" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x2.ifcexternallydefinedsurfacestyle' in typeof(style)])) <= 1 + + + + + + + + + + + + + + + + + + + + + + + +class IfcSweptAreaSolid_SweptAreaType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptAreaSolid" + RULE_NAME = "SweptAreaType" + + @staticmethod + def __call__(self): + sweptarea = self.SweptArea + + assert sweptarea.ProfileType == IfcProfileTypeEnum.Area + + + + + +class IfcSweptDiskSolid_DirectrixDim: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixDim" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSweptDiskSolid_InnerRadiusSize: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "InnerRadiusSize" + + @staticmethod + def __call__(self): + radius = self.Radius + innerradius = self.InnerRadius + + assert (not exists(innerradius)) or (radius > innerradius) + + + + +class IfcSweptDiskSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x2.ifcconic','ifc4x2.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + +class IfcSweptDiskSolidPolygonal_CorrectRadii: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "CorrectRadii" + + @staticmethod + def __call__(self): + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or (filletradius >= self.Radius) + + + + +class IfcSweptDiskSolidPolygonal_DirectrixIsPolyline: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "DirectrixIsPolyline" + + @staticmethod + def __call__(self): + + + assert ('ifc4x2.ifcpolyline' in typeof(self.Directrix)) or (('ifc4x2.ifcindexedpolycurve' in typeof(self.Directrix)) and (not exists(self.Directrix.Segments))) + + + + + +class IfcSweptSurface_SweptCurveType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptSurface" + RULE_NAME = "SweptCurveType" + + @staticmethod + def __call__(self): + sweptcurve = self.SweptCurve + + assert sweptcurve.ProfileType == IfcProfileTypeEnum.Curve + + + + + +class IfcSwitchingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSwitchingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcswitchingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSwitchingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSystemFurnitureElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSystemFurnitureElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcsystemfurnitureelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSystemFurnitureElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < depth + + + + +class IfcTShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcTable_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + rows = self.Rows + + assert (sizeof([temp for temp in rows if hiindex(temp.RowCells) != (hiindex(rows[1 - 1].RowCells))])) == 0 + + + + +class IfcTable_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + numberofheadings = self.NumberOfHeadings + + assert 0 <= numberofheadings <= 1 + + + + +def calc_IfcTable_NumberOfCellsInRow(self): + rows = self.Rows + return \ + hiindex(rows[1 - 1].RowCells) + + + +def calc_IfcTable_NumberOfHeadings(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if temp.IsHeading]) + + + +def calc_IfcTable_NumberOfDataRows(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if not temp.IsHeading]) + + + + + + + + + + +class IfcTank_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTank_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifctanktype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTankType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTankType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTask_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTask_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcTaskType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTaskType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + +class IfcTelecomAddress_MinimumDataProvided: + SCOPE = "entity" + TYPE_NAME = "IfcTelecomAddress" + RULE_NAME = "MinimumDataProvided" + + @staticmethod + def __call__(self): + telephonenumbers = self.TelephoneNumbers + facsimilenumbers = self.FacsimileNumbers + pagernumber = self.PagerNumber + electronicmailaddresses = self.ElectronicMailAddresses + wwwhomepageurl = self.WWWHomePageURL + messagingids = self.MessagingIDs + + assert exists(telephonenumbers) or exists(facsimilenumbers) or exists(pagernumber) or exists(electronicmailaddresses) or exists(wwwhomepageurl) or exists(messagingids) + + + + + +class IfcTendon_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendon_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifctendontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonAnchor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifctendonanchortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonConduit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonConduit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifctendonconduittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonConduitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcTessellatedFaceSet_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcTextLiteralWithExtent_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcTextLiteralWithExtent" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + extent = self.Extent + + assert not 'ifc4x2.ifcplanarbox' in typeof(extent) + + + + + + + + +class IfcTextStyleFontModel_MeasureOfFontSize: + SCOPE = "entity" + TYPE_NAME = "IfcTextStyleFontModel" + RULE_NAME = "MeasureOfFontSize" + + @staticmethod + def __call__(self): + + + assert ('ifc4x2.ifclengthmeasure' in typeof(self.FontSize)) and (self.FontSize > 0.) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTopologyRepresentation_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x2.ifctopologicalrepresentationitem' in typeof(temp)])) == 0 + + + + +class IfcTopologyRepresentation_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcTopologyRepresentation_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + + + assert IfcTopologyRepresentationTypes(self.RepresentationType,self.Items) + + + + + +class IfcToroidalSurface_MajorLargerMinor: + SCOPE = "entity" + TYPE_NAME = "IfcToroidalSurface" + RULE_NAME = "MajorLargerMinor" + + @staticmethod + def __call__(self): + majorradius = self.MajorRadius + minorradius = self.MinorRadius + + assert minorradius < majorradius + + + + + +class IfcTransformer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransformer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifctranformertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransformerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcTransportElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransportElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransportElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransportElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifctransportelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransportElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransportElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransportElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcTriangulatedFaceSet_NumberOfTriangles(self): + coordindex = self.CoordIndex + return \ + sizeof(coordindex) + + + + +class IfcTriangulatedIrregularNetwork_NotClosed: + SCOPE = "entity" + TYPE_NAME = "IfcTriangulatedIrregularNetwork" + RULE_NAME = "NotClosed" + + @staticmethod + def __call__(self): + + + assert self.Closed == False + + + + + +class IfcTrimmedCurve_Trim1ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim1ValuesConsistent" + + @staticmethod + def __call__(self): + trim1 = self.Trim1 + + assert (hiindex(trim1) == 1) or ((typeof(trim1[1 - 1])) != (typeof(trim1[2 - 1]))) + + + + +class IfcTrimmedCurve_Trim2ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim2ValuesConsistent" + + @staticmethod + def __call__(self): + trim2 = self.Trim2 + + assert (hiindex(trim2) == 1) or ((typeof(trim2[1 - 1])) != (typeof(trim2[2 - 1]))) + + + + +class IfcTrimmedCurve_NoTrimOfBoundedCurves: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "NoTrimOfBoundedCurves" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert not 'ifc4x2.ifcboundedcurve' in typeof(basiscurve) + + + + + +class IfcTubeBundle_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTubeBundle_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifctubebundletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTubeBundleType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundleType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTypeObject_NameRequired: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "NameRequired" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTypeObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + haspropertysets = self.HasPropertySets + + assert (not exists(haspropertysets)) or IfcUniquePropertySetNames(haspropertysets) + + + + + + + + +class IfcTypeProduct_ApplicableOccurrence: + SCOPE = "entity" + TYPE_NAME = "IfcTypeProduct" + RULE_NAME = "ApplicableOccurrence" + + @staticmethod + def __call__(self): + + + assert (not exists(lambda: self.Types[1 - 1])) or ((sizeof([temp for temp in self.Types[1 - 1].RelatedObjects if not 'ifc4x2.ifcproduct' in typeof(temp)])) == 0) + + + + + + + + +class IfcUShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + +class IfcUShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcUnitAssignment_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcUnitAssignment" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + units = self.Units + + assert IfcCorrectUnitAssignment(units) + + + + + +class IfcUnitaryControlElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryControlElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcunitarycontrolelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryControlElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcUnitaryEquipment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryEquipment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcunitaryequipmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryEquipmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcValve_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcValve_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcvalvetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcValveType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValveType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVector_MagGreaterOrEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcVector" + RULE_NAME = "MagGreaterOrEqualZero" + + @staticmethod + def __call__(self): + magnitude = self.Magnitude + + assert magnitude >= 0.0 + + + + +def calc_IfcVector_Dim(self): + orientation = self.Orientation + return \ + orientation.Dim + + + + + + + + + + + + + +class IfcVibrationDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcvibrationdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVibrationIsolator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationIsolator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcvibrationisolatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationIsolatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcVoidingFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcVoidingFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVoidingFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWallElementedCase_HasDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcWallElementedCase" + RULE_NAME = "HasDecomposition" + + @staticmethod + def __call__(self): + + + assert hiindex(self.IsDecomposedBy) > 0 + + + + + +class IfcWallStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcWallStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x2.ifcrelassociates.relatedobjects') if ('ifc4x2.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x2.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWasteTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWasteTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcwasteterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWasteTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWindow_CorrectStyleAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectStyleAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x2.ifcwindowtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWindowLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcWindowLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + firsttransomoffset = self.FirstTransomOffset + secondtransomoffset = self.SecondTransomOffset + + assert not (not exists(firsttransomoffset)) and exists(secondtransomoffset) + + + + +class IfcWindowLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + firstmullionoffset = self.FirstMullionOffset + secondmullionoffset = self.SecondMullionOffset + + assert not (not exists(firstmullionoffset)) and exists(secondmullionoffset) + + + + +class IfcWindowLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x2.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x2.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcWindowPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x2.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x2.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + + + + + + + +class IfcWindowType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWindowTypeEnum.USERDEFINED) or ((predefinedtype == IfcWindowTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWorkCalendar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkCalendar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkCalendarTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkCalendarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcWorkPlan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkPlan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkPlanTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkPlanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcWorkSchedule_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkSchedule" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkScheduleTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkScheduleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcZShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcZShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + + +class IfcZone_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcZone" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof(self.IsGroupedBy) == 0) or ((sizeof([temp for temp in self.IsGroupedBy[1 - 1].RelatedObjects if not ('ifc4x2.ifczone' in typeof(temp)) or ('ifc4x2.ifcspace' in typeof(temp)) or ('ifc4x2.ifcspatialzone' in typeof(temp))])) == 0) + + + + + +class IfcRepresentationContextSameWCS: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcGeometricRepresentationContext = file.by_type("IfcGeometricRepresentationContext") + isdifferent = False + if sizeof(IfcGeometricRepresentationContext) > 1: + for i in range(2, hiindex(IfcGeometricRepresentationContext) + 1): + if (IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem) != (IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem): + isdifferent = (not IfcSameValidPrecision(IfcGeometricRepresentationContext[1 - 1].Precision,IfcGeometricRepresentationContext[i - 1].Precision)) or (not IfcSameAxis2Placement(IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[1 - 1].Precision)) + if isdifferent == True: + break + + assert isdifferent == False + + + + + +class IfcSingleProjectInstance: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcProject = file.by_type("IfcProject") + + + + assert sizeof(IfcProject) <= 1 + + + + +def IfcAssociatedSurface(arg): + + surf = arg.BasisSurface + return surf + + +def IfcBaseAxis(dim, axis1, axis2, axis3): + + + + if dim == 3: + d1 = nvl(IfcNormalise(axis3),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,axis1) + u = [d2,IfcSecondProjAxis(d1,d2,axis2),d1] + else: + if exists(axis1): + d1 = IfcNormalise(axis1) + u = [d1,IfcOrthogonalComplement(d1)] + if exists(axis2): + factor = IfcDotProduct(axis2,u[2 - 1]) + if factor < 0.0: + u[2 - 1].DirectionRatios[1 - 1] = -u[2 - 1].DirectionRatios[1 - 1] + u[2 - 1].DirectionRatios[2 - 1] = -u[2 - 1].DirectionRatios[2 - 1] + else: + if exists(axis2): + d1 = IfcNormalise(axis2) + u = [IfcOrthogonalComplement(d1),d1] + u[1 - 1].DirectionRatios[1 - 1] = -u[1 - 1].DirectionRatios[1 - 1] + u[1 - 1].DirectionRatios[2 - 1] = -u[1 - 1].DirectionRatios[2 - 1] + else: + u = [IfcDirection(DirectionRatios=[1.0,0.0]),IfcDirection(DirectionRatios=[0.0,1.0])] + return u + + +def IfcBooleanChoose(b, choice1, choice2): + + if b: + return choice1 + else: + return choice2 + + +def IfcBuild2Axes(refdirection): + d = nvl(IfcNormalise(refdirection),IfcDirection(DirectionRatios=[1.0,0.0])) + return [d,IfcOrthogonalComplement(d)] + + +def IfcBuildAxes(axis, refdirection): + + d1 = nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,refdirection) + return [d2,IfcNormalise(IfcCrossProduct(d1,d2)).Orientation,d1] + + +def IfcConsecutiveSegments(segments): + result = True + for i in range(1, hiindex(segments) - 1 + 1): + if (segments[i - 1][hiindex(segments[i - 1]) - 1]) != (segments[i - 1][1 - 1]): + result = False + break + return result + + +def IfcConstraintsParamBSpline(degree, upknots, upcp, knotmult, knots): + result = True + + sum = knotmult[1 - 1] + for i in range(2, upknots + 1): + sum = sum + (knotmult[i - 1]) + if (degree < 1) or (upknots < 2) or (upcp < degree) or (sum != (degree + upcp + 2)): + result = False + return result + k = knotmult[1 - 1] + if (k < 1) or (k > (degree + 1)): + result = False + return result + for i in range(2, upknots + 1): + if ((knotmult[i - 1]) < 1) or ((knots[i - 1]) <= (knots[i - 1])): + result = False + return result + k = knotmult[i - 1] + if (i < upknots) and (k > degree): + result = False + return result + if (i == upknots) and (k > (degree + 1)): + result = False + return result + return result + + +def IfcConvertDirectionInto2D(direction): + direction2d = IfcDirection(DirectionRatios=[0.,1.]) + temp = list(direction2d.DirectionRatios) + temp[1 - 1] = direction.DirectionRatios[1 - 1] + direction2d.DirectionRatios = temp + temp = list(direction2d.DirectionRatios) + temp[2 - 1] = direction.DirectionRatios[2 - 1] + direction2d.DirectionRatios = temp + return direction2d + + +def IfcCorrectDimensions(m, dim): + + if m == lengthunit: + if dim == IfcDimensionalExponents(1,0,0,0,0,0,0): + return True + else: + return False + elif m == massunit: + if dim == IfcDimensionalExponents(0,1,0,0,0,0,0): + return True + else: + return False + elif m == timeunit: + if dim == IfcDimensionalExponents(0,0,1,0,0,0,0): + return True + else: + return False + elif m == electriccurrentunit: + if dim == IfcDimensionalExponents(0,0,0,1,0,0,0): + return True + else: + return False + elif m == thermodynamictemperatureunit: + if dim == IfcDimensionalExponents(0,0,0,0,1,0,0): + return True + else: + return False + elif m == amountofsubstanceunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,1,0): + return True + else: + return False + elif m == luminousintensityunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == planeangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == solidangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == areaunit: + if dim == IfcDimensionalExponents(2,0,0,0,0,0,0): + return True + else: + return False + elif m == volumeunit: + if dim == IfcDimensionalExponents(3,0,0,0,0,0,0): + return True + else: + return False + elif m == absorbeddoseunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == radioactivityunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == electriccapacitanceunit: + if dim == IfcDimensionalExponents(-2,-1,4,2,0,0,0): + return True + else: + return False + elif m == doseequivalentunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == electricchargeunit: + if dim == IfcDimensionalExponents(0,0,1,1,0,0,0): + return True + else: + return False + elif m == electricconductanceunit: + if dim == IfcDimensionalExponents(-2,-1,3,2,0,0,0): + return True + else: + return False + elif m == electricvoltageunit: + if dim == IfcDimensionalExponents(2,1,-3,-1,0,0,0): + return True + else: + return False + elif m == electricresistanceunit: + if dim == IfcDimensionalExponents(2,1,-3,-2,0,0,0): + return True + else: + return False + elif m == energyunit: + if dim == IfcDimensionalExponents(2,1,-2,0,0,0,0): + return True + else: + return False + elif m == forceunit: + if dim == IfcDimensionalExponents(1,1,-2,0,0,0,0): + return True + else: + return False + elif m == frequencyunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == inductanceunit: + if dim == IfcDimensionalExponents(2,1,-2,-2,0,0,0): + return True + else: + return False + elif m == illuminanceunit: + if dim == IfcDimensionalExponents(-2,0,0,0,0,0,1): + return True + else: + return False + elif m == luminousfluxunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == magneticfluxunit: + if dim == IfcDimensionalExponents(2,1,-2,-1,0,0,0): + return True + else: + return False + elif m == magneticfluxdensityunit: + if dim == IfcDimensionalExponents(0,1,-2,-1,0,0,0): + return True + else: + return False + elif m == powerunit: + if dim == IfcDimensionalExponents(2,1,-3,0,0,0,0): + return True + else: + return False + elif m == pressureunit: + if dim == IfcDimensionalExponents(-1,1,-2,0,0,0,0): + return True + else: + return False + else: + return unknown + + +def IfcCorrectFillAreaStyle(styles): + hatching = 0 + tiles = 0 + colour = 0 + external = 0 + external = sizeof([style for style in styles if 'ifc4x2.ifcexternallydefinedhatchstyle' in typeof(style)]) + hatching = sizeof([style for style in styles if 'ifc4x2.ifcfillareastylehatching' in typeof(style)]) + tiles = sizeof([style for style in styles if 'ifc4x2.ifcfillareastyletiles' in typeof(style)]) + colour = sizeof([style for style in styles if 'ifc4x2.ifccolour' in typeof(style)]) + if external > 1: + return False + if (external == 1) and ((hatching > 0) or (tiles > 0) or (colour > 0)): + return False + if colour > 1: + return False + if (hatching > 0) and (tiles > 0): + return False + return True + + +def IfcCorrectLocalPlacement(axisplacement, relplacement): + + if exists(relplacement): + if 'ifc4x2.ifcgridplacement' in typeof(relplacement): + return None + if 'ifc4x2.ifclocalplacement' in typeof(relplacement): + if 'ifc4x2.ifcaxis2placement2d' in typeof(axisplacement): + return True + if 'ifc4x2.ifcaxis2placement3d' in typeof(axisplacement): + if relplacement.RelativePlacement.Dim == 3: + return True + else: + return False + return True + return None + + +def IfcCorrectObjectAssignment(constraint, objects): + count = 0 + if not exists(constraint): + return True + if constraint == IfcObjectTypeEnum.NOTDEFINED: + return True + elif constraint == IfcObjectTypeEnum.PRODUCT: + count = sizeof([temp for temp in objects if not 'ifc4x2.ifcproduct' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROCESS: + count = sizeof([temp for temp in objects if not 'ifc4x2.ifcprocess' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.CONTROL: + count = sizeof([temp for temp in objects if not 'ifc4x2.ifccontrol' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.RESOURCE: + count = sizeof([temp for temp in objects if not 'ifc4x2.ifcresource' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.ACTOR: + count = sizeof([temp for temp in objects if not 'ifc4x2.ifcactor' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.GROUP: + count = sizeof([temp for temp in objects if not 'ifc4x2.ifcgroup' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROJECT: + count = sizeof([temp for temp in objects if not 'ifc4x2.ifcproject' in typeof(temp)]) + return count == 0 + else: + return None + + +def IfcCorrectUnitAssignment(units): + namedunitnumber = 0 + derivedunitnumber = 0 + monetaryunitnumber = 0 + namedunitnames = express_set([]) + derivedunitnames = express_set([]) + namedunitnumber = sizeof([temp for temp in units if ('ifc4x2.ifcnamedunit' in typeof(temp)) and (not temp.UnitType == IfcUnitEnum.USERDEFINED)]) + derivedunitnumber = sizeof([temp for temp in units if ('ifc4x2.ifcderivedunit' in typeof(temp)) and (not temp.UnitType == IfcDerivedUnitEnum.USERDEFINED)]) + monetaryunitnumber = sizeof([temp for temp in units if 'ifc4x2.ifcmonetaryunit' in typeof(temp)]) + for i in range(1, sizeof(units) + 1): + if ('ifc4x2.ifcnamedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcUnitEnum.USERDEFINED): + namedunitnames = namedunitnames + (units[i - 1].UnitType) + if ('ifc4x2.ifcderivedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcDerivedUnitEnum.USERDEFINED): + derivedunitnames = derivedunitnames + (units[i - 1].UnitType) + return (sizeof(namedunitnames) == namedunitnumber) and (sizeof(derivedunitnames) == derivedunitnumber) and (monetaryunitnumber <= 1) + + +def IfcCrossProduct(arg1, arg2): + + + + + if ((not exists(arg1)) or (arg1.Dim == 2)) or ((not exists(arg2)) or (arg2.Dim == 2)): + return None + else: + v1 = IfcNormalise(arg1).DirectionRatios + v2 = IfcNormalise(arg2).DirectionRatios + res = IfcDirection(DirectionRatios=[((v1[2 - 1]) * (v2[3 - 1])) - ((v1[3 - 1]) * (v2[2 - 1])),((v1[3 - 1]) * (v2[1 - 1])) - ((v1[1 - 1]) * (v2[3 - 1])),((v1[1 - 1]) * (v2[2 - 1])) - ((v1[2 - 1]) * (v2[1 - 1]))]) + mag = 0.0 + for i in range(1, 3 + 1): + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=arg1, Magnitude=0.0) + return result + + +def IfcCurveDim(curve): + + if 'ifc4x2.ifcline' in typeof(curve): + return curve.Pnt.Dim + if 'ifc4x2.ifcconic' in typeof(curve): + return curve.Position.Dim + if 'ifc4x2.ifcpolyline' in typeof(curve): + return curve.Points[1 - 1].Dim + if 'ifc4x2.ifctrimmedcurve' in typeof(curve): + return IfcCurveDim(curve.BasisCurve) + if 'ifc4x2.ifccompositecurve' in typeof(curve): + return curve.Segments[1 - 1].Dim + if 'ifc4x2.ifcbsplinecurve' in typeof(curve): + return curve.ControlPointsList[1 - 1].Dim + if 'ifc4x2.ifcoffsetcurve2d' in typeof(curve): + return 2 + if 'ifc4x2.ifcoffsetcurve3d' in typeof(curve): + return 3 + if 'ifc4x2.ifcoffsetcurvebydistances' in typeof(curve): + return 3 + if 'ifc4x2.ifccurvesegment2d' in typeof(curve): + return 2 + if 'ifc4x2.ifcalignmentcurve' in typeof(curve): + return 3 + if 'ifc4x2.ifcpcurve' in typeof(curve): + return 3 + if 'ifc4x2.ifcindexedpolycurve' in typeof(curve): + return curve.Points.Dim + return None + + +def IfcCurveWeightsPositive(b): + result = True + for i in range(0, b.UpperIndexOnControlPoints + 1): + if (b.Weights[i - 1]) <= 0.0: + result = False + return result + return result + + +def IfcDeriveDimensionalExponents(unitelements): + result = IfcDimensionalExponents(0,0,0,0,0,0,0) + for i in range(loindex(unitelements), hiindex(unitelements) + 1): + result.LengthExponent = result.LengthExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LengthExponent)) + result.MassExponent = result.MassExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.MassExponent)) + result.TimeExponent = result.TimeExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.TimeExponent)) + result.ElectricCurrentExponent = result.ElectricCurrentExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ElectricCurrentExponent)) + result.ThermodynamicTemperatureExponent = result.ThermodynamicTemperatureExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ThermodynamicTemperatureExponent)) + result.AmountOfSubstanceExponent = result.AmountOfSubstanceExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.AmountOfSubstanceExponent)) + result.LuminousIntensityExponent = result.LuminousIntensityExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LuminousIntensityExponent)) + return result + + +def IfcDimensionsForSiUnit(n): + + if n == metre: + return IfcDimensionalExponents(1,0,0,0,0,0,0) + elif n == square_metre: + return IfcDimensionalExponents(2,0,0,0,0,0,0) + elif n == cubic_metre: + return IfcDimensionalExponents(3,0,0,0,0,0,0) + elif n == gram: + return IfcDimensionalExponents(0,1,0,0,0,0,0) + elif n == second: + return IfcDimensionalExponents(0,0,1,0,0,0,0) + elif n == ampere: + return IfcDimensionalExponents(0,0,0,1,0,0,0) + elif n == kelvin: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == mole: + return IfcDimensionalExponents(0,0,0,0,0,1,0) + elif n == candela: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == radian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == steradian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == hertz: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == newton: + return IfcDimensionalExponents(1,1,-2,0,0,0,0) + elif n == pascal: + return IfcDimensionalExponents(-1,1,-2,0,0,0,0) + elif n == joule: + return IfcDimensionalExponents(2,1,-2,0,0,0,0) + elif n == watt: + return IfcDimensionalExponents(2,1,-3,0,0,0,0) + elif n == coulomb: + return IfcDimensionalExponents(0,0,1,1,0,0,0) + elif n == volt: + return IfcDimensionalExponents(2,1,-3,-1,0,0,0) + elif n == farad: + return IfcDimensionalExponents(-2,-1,4,2,0,0,0) + elif n == ohm: + return IfcDimensionalExponents(2,1,-3,-2,0,0,0) + elif n == siemens: + return IfcDimensionalExponents(-2,-1,3,2,0,0,0) + elif n == weber: + return IfcDimensionalExponents(2,1,-2,-1,0,0,0) + elif n == tesla: + return IfcDimensionalExponents(0,1,-2,-1,0,0,0) + elif n == henry: + return IfcDimensionalExponents(2,1,-2,-2,0,0,0) + elif n == degree_celsius: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == lumen: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == lux: + return IfcDimensionalExponents(-2,0,0,0,0,0,1) + elif n == becquerel: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == gray: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + elif n == sievert: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + else: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + + +def IfcDotProduct(arg1, arg2): + + + + if (not exists(arg1)) or (not exists(arg2)): + scalar = None + else: + if arg1.Dim != arg2.Dim: + scalar = None + else: + vec1 = IfcNormalise(arg1) + vec2 = IfcNormalise(arg2) + ndim = arg1.Dim + scalar = 0.0 + for i in range(1, ndim + 1): + scalar = scalar + ((vec1.DirectionRatios[i - 1]) * (vec2.DirectionRatios[i - 1])) + return scalar + + +def IfcFirstProjAxis(zaxis, arg): + + + + + if not exists(zaxis): + return None + else: + z = IfcNormalise(zaxis) + if not exists(arg): + if z.DirectionRatios != [1.0,0.0,0.0]: + v = IfcDirection(DirectionRatios=[1.0,0.0,0.0]) + else: + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + if arg.Dim != 3: + return None + if IfcCrossProduct(arg,z).Magnitude == 0.0: + return None + else: + v = IfcNormalise(arg) + xvec = IfcScalarTimesVector(IfcDotProduct(v,z),z) + xaxis = IfcVectorDifference(v,xvec).Orientation + xaxis = IfcNormalise(xaxis) + return xaxis + + +def IfcGetBasisSurface(c): + + + surfs = [] + if 'ifc4x2.ifcpcurve' in typeof(c): + surfs = [c.BasisSurface] + else: + if 'ifc4x2.ifcsurfacecurve' in typeof(c): + n = sizeof(c.AssociatedGeometry) + for i in range(1, n + 1): + surfs = surfs + (IfcAssociatedSurface(c.AssociatedGeometry[i - 1])) + if 'ifc4x2.ifccompositecurveonsurface' in typeof(c): + n = sizeof(c.Segments) + surfs = IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve) + if n > 1: + for i in range(2, n + 1): + surfs = surfs * (IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve)) + return surfs + + +def IfcListToArray(lis, low, u): + + + n = sizeof(lis) + if n != (u - low + 1): + return None + else: + res = ([lis[1 - 1]] * n) + for i in range(2, n + 1): + temp = list(res) + temp[low - 1] = lis[i - 1] + res = temp + return res + + +def IfcLoopHeadToTail(aloop): + + p = True + n = sizeof(aloop.EdgeList) + for i in range(2, n + 1): + p = p and ((aloop.EdgeList[i - 1].EdgeEnd) == (aloop.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcMakeArrayOfArray(lis, low1, u1, low2, u2): + + if (u1 - low1 + 1) != sizeof(lis): + return None + if (u2 - low2 + 1) != (sizeof(lis[1 - 1])): + return None + res = ([IfcListToArray(lis[1 - 1],low2,u2)] * u1 - low1 + 1) + for i in range(2, hiindex(lis) + 1): + if (u2 - low2 + 1) != (sizeof(lis[i - 1])): + return None + temp = list(res) + temp[low1 - 1] = IfcListToArray(lis[i - 1],low2,u2) + res = temp + return res + + +def IfcMlsTotalThickness(layerset): + max = layerset.MaterialLayers[1 - 1].LayerThickness + if sizeof(layerset.MaterialLayers) > 1: + for i in range(2, hiindex(layerset.MaterialLayers) + 1): + max = max + (layerset.MaterialLayers[i - 1].LayerThickness) + return max + + +def IfcNormalise(arg): + + v = IfcDirection(DirectionRatios=[1.,0.]) + vec = IfcVector(Orientation=IfcDirection(DirectionRatios=[1.,0.]), Magnitude=1.) + + result = v + if not exists(arg): + return None + else: + if 'ifc4x2.ifcvector' in typeof(arg): + ndim = arg.Dim + v.DirectionRatios = arg.Orientation.DirectionRatios + vec.Magnitude = arg.Magnitude + vec.Orientation = v + if arg.Magnitude == 0.0: + return None + else: + vec.Magnitude = 1.0 + else: + ndim = arg.Dim + v.DirectionRatios = arg.DirectionRatios + mag = 0.0 + for i in range(1, ndim + 1): + mag = mag + ((v.DirectionRatios[i - 1]) * (v.DirectionRatios[i - 1])) + if mag > 0.0: + mag = sqrt(mag) + for i in range(1, ndim + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = (v.DirectionRatios[i - 1]) / mag + v.DirectionRatios = temp + if 'ifc4x2.ifcvector' in typeof(arg): + vec.Orientation = v + result = vec + else: + result = v + else: + return None + return result + + +def IfcOrthogonalComplement(vec): + + if (not exists(vec)) or (vec.Dim != 2): + return None + else: + result = IfcDirection(DirectionRatios=[-vec.DirectionRatios[2 - 1],vec.DirectionRatios[1 - 1]]) + return result + + +def IfcPathHeadToTail(apath): + n = 0 + p = unknown + n = sizeof(apath.EdgeList) + for i in range(2, n + 1): + p = p and ((apath.EdgeList[i - 1].EdgeEnd) == (apath.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcPointListDim(pointlist): + + if 'ifc4x2.ifccartesianpointlist2d' in typeof(pointlist): + return 2 + if 'ifc4x2.ifccartesianpointlist3d' in typeof(pointlist): + return 3 + return None + + +def IfcSameAxis2Placement(ap1, ap2, epsilon): + + return (IfcSameDirection(ap1.P[1 - 1],ap2.P[1 - 1],epsilon)) and (IfcSameDirection(ap1.P[2 - 1],ap2.P[2 - 1],epsilon)) and IfcSameCartesianPoint(ap1.Location,ap1.Location,epsilon) + + +def IfcSameCartesianPoint(cp1, cp2, epsilon): + cp1x = cp1.Coordinates[1 - 1] + cp1y = cp1.Coordinates[2 - 1] + cp1z = 0 + cp2x = cp2.Coordinates[1 - 1] + cp2y = cp2.Coordinates[2 - 1] + cp2z = 0 + if sizeof(cp1.Coordinates) > 2: + cp1z = cp1.Coordinates[3 - 1] + if sizeof(cp2.Coordinates) > 2: + cp2z = cp2.Coordinates[3 - 1] + return IfcSameValue(cp1x,cp2x,epsilon) and IfcSameValue(cp1y,cp2y,epsilon) and IfcSameValue(cp1z,cp2z,epsilon) + + +def IfcSameDirection(dir1, dir2, epsilon): + dir1x = dir1.DirectionRatios[1 - 1] + dir1y = dir1.DirectionRatios[2 - 1] + dir1z = 0 + dir2x = dir2.DirectionRatios[1 - 1] + dir2y = dir2.DirectionRatios[2 - 1] + dir2z = 0 + if sizeof(dir1.DirectionRatios) > 2: + dir1z = dir1.DirectionRatios[3 - 1] + if sizeof(dir2.DirectionRatios) > 2: + dir2z = dir2.DirectionRatios[3 - 1] + return IfcSameValue(dir1x,dir2x,epsilon) and IfcSameValue(dir1y,dir2y,epsilon) and IfcSameValue(dir1z,dir2z,epsilon) + + +def IfcSameValidPrecision(epsilon1, epsilon2): + + defaulteps = 0.000001 + derivationofeps = 1.001 + uppereps = 1.0 + valideps1 = nvl(epsilon1,defaulteps) + valideps2 = nvl(epsilon2,defaulteps) + return (0.0 < valideps1) and (valideps1 <= (derivationofeps * valideps2)) and (valideps2 <= (derivationofeps * valideps1)) and (valideps2 < uppereps) + + +def IfcSameValue(value1, value2, epsilon): + + defaulteps = 0.000001 + valideps = nvl(epsilon,defaulteps) + return ((value1 + valideps) > value2) and (value1 < (value2 + valideps)) + + +def IfcScalarTimesVector(scalar, vec): + + + + if (not exists(scalar)) or (not exists(vec)): + return None + else: + if 'ifc4x2.ifcvector' in typeof(vec): + v = vec.Orientation + mag = scalar * vec.Magnitude + else: + v = vec + mag = scalar + if mag < 0.0: + for i in range(1, sizeof(v.DirectionRatios) + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = -v.DirectionRatios[i - 1] + v.DirectionRatios = temp + mag = -mag + result = IfcVector(Orientation=IfcNormalise(v), Magnitude=mag) + return result + + +def IfcSecondProjAxis(zaxis, xaxis, arg): + + + + if not exists(arg): + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + v = arg + temp = IfcScalarTimesVector(IfcDotProduct(v,zaxis),zaxis) + yaxis = IfcVectorDifference(v,temp) + temp = IfcScalarTimesVector(IfcDotProduct(v,xaxis),xaxis) + yaxis = IfcVectorDifference(yaxis,temp) + yaxis = IfcNormalise(yaxis) + return yaxis.Orientation + + +def IfcShapeRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'point': + count = sizeof([temp for temp in items if 'ifc4x2.ifcpoint' in typeof(temp)]) + elif reptype.lower() == 'pointcloud': + count = sizeof([temp for temp in items if 'ifc4x2.ifccartesianpointlist3d' in typeof(temp)]) + elif reptype.lower() == 'curve': + count = sizeof([temp for temp in items if 'ifc4x2.ifccurve' in typeof(temp)]) + elif reptype.lower() == 'curve2d': + count = sizeof([temp for temp in items if ('ifc4x2.ifccurve' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'curve3d': + count = sizeof([temp for temp in items if ('ifc4x2.ifccurve' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'surface': + count = sizeof([temp for temp in items if 'ifc4x2.ifcsurface' in typeof(temp)]) + elif reptype.lower() == 'surface2d': + count = sizeof([temp for temp in items if ('ifc4x2.ifcsurface' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'surface3d': + count = sizeof([temp for temp in items if ('ifc4x2.ifcsurface' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'fillarea': + count = sizeof([temp for temp in items if 'ifc4x2.ifcannotationfillarea' in typeof(temp)]) + elif reptype.lower() == 'text': + count = sizeof([temp for temp in items if 'ifc4x2.ifctextliteral' in typeof(temp)]) + elif reptype.lower() == 'advancedsurface': + count = sizeof([temp for temp in items if 'ifc4x2.ifcbsplinesurface' in typeof(temp)]) + elif reptype.lower() == 'annotation2d': + count = sizeof([temp for temp in items if (sizeof(typeof(temp) * ['ifc4x2.ifcpoint','ifc4x2.ifccurve','ifc4x2.ifcgeometriccurveset','ifc4x2.ifcannotationfillarea','ifc4x2.ifctextliteral'])) == 1]) + elif reptype.lower() == 'geometricset': + count = sizeof([temp for temp in items if ('ifc4x2.ifcgeometricset' in typeof(temp)) or ('ifc4x2.ifcpoint' in typeof(temp)) or ('ifc4x2.ifccurve' in typeof(temp)) or ('ifc4x2.ifcsurface' in typeof(temp))]) + elif reptype.lower() == 'geometriccurveset': + count = sizeof([temp for temp in items if ('ifc4x2.ifcgeometriccurveset' in typeof(temp)) or ('ifc4x2.ifcgeometricset' in typeof(temp)) or ('ifc4x2.ifcpoint' in typeof(temp)) or ('ifc4x2.ifccurve' in typeof(temp))]) + for i in range(1, hiindex(items) + 1): + if 'ifc4x2.ifcgeometricset' in (typeof(items[i - 1])): + if (sizeof([temp for temp in items[i - 1].Elements if 'ifc4x2.ifcsurface' in typeof(temp)])) > 0: + count = count - 1 + elif reptype.lower() == 'tessellation': + count = sizeof([temp for temp in items if 'ifc4x2.ifctessellateditem' in typeof(temp)]) + elif reptype.lower() == 'surfaceorsolidmodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x2.ifctessellateditem','ifc4x2.ifcshellbasedsurfacemodel','ifc4x2.ifcfacebasedsurfacemodel','ifc4x2.ifcsolidmodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'surfacemodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x2.ifctessellateditem','ifc4x2.ifcshellbasedsurfacemodel','ifc4x2.ifcfacebasedsurfacemodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'solidmodel': + count = sizeof([temp for temp in items if 'ifc4x2.ifcsolidmodel' in typeof(temp)]) + elif reptype.lower() == 'sweptsolid': + count = sizeof([temp for temp in items if ((sizeof(['ifc4x2.ifcextrudedareasolid','ifc4x2.ifcrevolvedareasolid'] * typeof(temp))) >= 1) and ((sizeof(['ifc4x2.ifcextrudedareasolidtapered','ifc4x2.ifcrevolvedareasolidtapered'] * typeof(temp))) == 0)]) + elif reptype.lower() == 'advancedsweptsolid': + count = sizeof([temp for temp in items if (sizeof(['ifc4x2.ifcsweptareasolid','ifc4x2.ifcsweptdisksolid'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'csg': + count = sizeof([temp for temp in items if (sizeof(['ifc4x2.ifcbooleanresult','ifc4x2.ifccsgprimitive3d','ifc4x2.ifccsgsolid'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'clipping': + count = sizeof([temp for temp in items if (sizeof(['ifc4x2.ifccsgsolid','ifc4x2.ifcbooleanclippingresult'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'brep': + count = sizeof([temp for temp in items if 'ifc4x2.ifcfacetedbrep' in typeof(temp)]) + elif reptype.lower() == 'advancedbrep': + count = sizeof([temp for temp in items if 'ifc4x2.ifcmanifoldsolidbrep' in typeof(temp)]) + elif reptype.lower() == 'boundingbox': + count = sizeof([temp for temp in items if 'ifc4x2.ifcboundingbox' in typeof(temp)]) + if sizeof(items) > 1: + count = 0 + elif reptype.lower() == 'sectionedspine': + count = sizeof([temp for temp in items if 'ifc4x2.ifcsectionedspine' in typeof(temp)]) + elif reptype.lower() == 'lightsource': + count = sizeof([temp for temp in items if 'ifc4x2.ifclightsource' in typeof(temp)]) + elif reptype.lower() == 'mappedrepresentation': + count = sizeof([temp for temp in items if 'ifc4x2.ifcmappeditem' in typeof(temp)]) + else: + return None + return count == sizeof(items) + + +def IfcSurfaceWeightsPositive(b): + result = True + weights = b.Weights + for i in range(0, b.UUpper + 1): + for j in range(0, b.VUpper + 1): + if (weights[i - 1][j - 1]) <= 0.0: + result = False + return result + return result + + +def IfcTaperedSweptAreaProfiles(startarea, endarea): + result = False + if 'ifc4x2.ifcparameterizedprofiledef' in typeof(startarea): + if 'ifc4x2.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = typeof(startarea) == typeof(endarea) + else: + if 'ifc4x2.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = False + return result + + +def IfcTopologyRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'vertex': + count = sizeof([temp for temp in items if 'ifc4x2.ifcvertex' in typeof(temp)]) + elif reptype.lower() == 'edge': + count = sizeof([temp for temp in items if 'ifc4x2.ifcedge' in typeof(temp)]) + elif reptype.lower() == 'path': + count = sizeof([temp for temp in items if 'ifc4x2.ifcpath' in typeof(temp)]) + elif reptype.lower() == 'face': + count = sizeof([temp for temp in items if 'ifc4x2.ifcface' in typeof(temp)]) + elif reptype.lower() == 'shell': + count = sizeof([temp for temp in items if ('ifc4x2.ifcopenshell' in typeof(temp)) or ('ifc4x2.ifcclosedshell' in typeof(temp))]) + elif reptype.lower() == 'undefined': + return True + else: + return None + return count == sizeof(items) + + +def IfcUniqueDefinitionNames(relations): + + + properties = express_set([]) + + if sizeof(relations) == 0: + return True + for i in range(1, hiindex(relations) + 1): + definition = relations[i - 1].RelatingPropertyDefinition + if 'ifc4x2.ifcpropertysetdefinition' in typeof(definition): + properties = properties + definition + else: + if 'ifc4x2.ifcpropertysetdefinitionset' in typeof(definition): + definitionset = definition + for j in range(1, hiindex(definitionset) + 1): + properties = properties + (definitionset[j - 1]) + result = IfcUniquePropertySetNames(properties) + return result + + +def IfcUniquePropertyName(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniquePropertySetNames(properties): + names = express_set([]) + unnamed = 0 + for i in range(1, hiindex(properties) + 1): + if 'ifc4x2.ifcpropertyset' in (typeof(properties[i - 1])): + names = names + (properties[i - 1].Name) + else: + unnamed = unnamed + 1 + return (sizeof(names) + unnamed) == sizeof(properties) + + +def IfcUniquePropertyTemplateNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniqueQuantityNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcVectorDifference(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x2.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x2.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) - (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + +def IfcVectorSum(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x2.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x2.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) + (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + diff --git a/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3.py b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3.py new file mode 100644 index 0000000000..3ab78ffe84 --- /dev/null +++ b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3.py @@ -0,0 +1,25296 @@ +import ifcopenshell + +def exists(v): + if callable(v): + try: return v() is not None + except IndexError as e: return False + else: return v is not None + + + +def nvl(v, default): return v if v is not None else default + + +sizeof = len +hiindex = len +blength = len +loindex = lambda x: 1 +from math import * +unknown = 'UNKNOWN' + +def usedin(inst, ref_name): + if inst is None: + return [] + _, __, attr = ref_name.split('.') + def filter(): + for ref, attr_idx in inst.wrapped_data.file.get_inverse(inst, allow_duplicate=True, with_attribute_indices=True): + if ref.wrapped_data.get_attribute_names()[attr_idx].lower() == attr: + yield ref + return list(filter()) + + +class express_set(set): + def __rmul__(self, other): + return express_set(set(other) & self) + def __add__(self, other): + def make_list(v): + # Comply with 12.6.3 Union operator + if isinstance(v, (list, tuple, set, express_set)): + return list(v) + else: + return [v] + return express_set(list(self) + make_list(other)) + __radd__ = __add__ + def __repr__(self): + return repr(set(self)) + + +def typeof(inst): + if not inst: + # If V evaluates to indeterminate (?), an empty set is returned. + return express_set([]) + schema_name = inst.is_a(True).split('.')[0].lower() + def inner(): + decl = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(inst.is_a()) + while decl: + yield '.'.join((schema_name, decl.name().lower())) + decl = decl.supertype() + return express_set(inner()) + +class enum_namespace: + def __getattr__(self, k): + return k.upper() + + +IfcActionRequestTypeEnum = enum_namespace() + + +email = IfcActionRequestTypeEnum.EMAIL + + +fax = IfcActionRequestTypeEnum.FAX + + +phone = IfcActionRequestTypeEnum.PHONE + + +post = IfcActionRequestTypeEnum.POST + + +verbal = IfcActionRequestTypeEnum.VERBAL + + +userdefined = IfcActionRequestTypeEnum.USERDEFINED + + +notdefined = IfcActionRequestTypeEnum.NOTDEFINED + + +IfcActionSourceTypeEnum = enum_namespace() + + +brakes = IfcActionSourceTypeEnum.BRAKES + + +buoyancy = IfcActionSourceTypeEnum.BUOYANCY + + +completion_g1 = IfcActionSourceTypeEnum.COMPLETION_G1 + + +creep = IfcActionSourceTypeEnum.CREEP + + +current = IfcActionSourceTypeEnum.CURRENT + + +dead_load_g = IfcActionSourceTypeEnum.DEAD_LOAD_G + + +earthquake_e = IfcActionSourceTypeEnum.EARTHQUAKE_E + + +erection = IfcActionSourceTypeEnum.ERECTION + + +fire = IfcActionSourceTypeEnum.FIRE + + +ice = IfcActionSourceTypeEnum.ICE + + +impact = IfcActionSourceTypeEnum.IMPACT + + +impulse = IfcActionSourceTypeEnum.IMPULSE + + +lack_of_fit = IfcActionSourceTypeEnum.LACK_OF_FIT + + +live_load_q = IfcActionSourceTypeEnum.LIVE_LOAD_Q + + +prestressing_p = IfcActionSourceTypeEnum.PRESTRESSING_P + + +propping = IfcActionSourceTypeEnum.PROPPING + + +rain = IfcActionSourceTypeEnum.RAIN + + +settlement_u = IfcActionSourceTypeEnum.SETTLEMENT_U + + +shrinkage = IfcActionSourceTypeEnum.SHRINKAGE + + +snow_s = IfcActionSourceTypeEnum.SNOW_S + + +system_imperfection = IfcActionSourceTypeEnum.SYSTEM_IMPERFECTION + + +temperature_t = IfcActionSourceTypeEnum.TEMPERATURE_T + + +transport = IfcActionSourceTypeEnum.TRANSPORT + + +wave = IfcActionSourceTypeEnum.WAVE + + +wind_w = IfcActionSourceTypeEnum.WIND_W + + +userdefined = IfcActionSourceTypeEnum.USERDEFINED + + +notdefined = IfcActionSourceTypeEnum.NOTDEFINED + + +IfcActionTypeEnum = enum_namespace() + + +extraordinary_a = IfcActionTypeEnum.EXTRAORDINARY_A + + +permanent_g = IfcActionTypeEnum.PERMANENT_G + + +variable_q = IfcActionTypeEnum.VARIABLE_Q + + +userdefined = IfcActionTypeEnum.USERDEFINED + + +notdefined = IfcActionTypeEnum.NOTDEFINED + + +IfcActuatorTypeEnum = enum_namespace() + + +electricactuator = IfcActuatorTypeEnum.ELECTRICACTUATOR + + +handoperatedactuator = IfcActuatorTypeEnum.HANDOPERATEDACTUATOR + + +hydraulicactuator = IfcActuatorTypeEnum.HYDRAULICACTUATOR + + +pneumaticactuator = IfcActuatorTypeEnum.PNEUMATICACTUATOR + + +thermostaticactuator = IfcActuatorTypeEnum.THERMOSTATICACTUATOR + + +userdefined = IfcActuatorTypeEnum.USERDEFINED + + +notdefined = IfcActuatorTypeEnum.NOTDEFINED + + +IfcAddressTypeEnum = enum_namespace() + + +distributionpoint = IfcAddressTypeEnum.DISTRIBUTIONPOINT + + +home = IfcAddressTypeEnum.HOME + + +office = IfcAddressTypeEnum.OFFICE + + +site = IfcAddressTypeEnum.SITE + + +userdefined = IfcAddressTypeEnum.USERDEFINED + + +IfcAirTerminalBoxTypeEnum = enum_namespace() + + +constantflow = IfcAirTerminalBoxTypeEnum.CONSTANTFLOW + + +variableflowpressuredependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREDEPENDANT + + +variableflowpressureindependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREINDEPENDANT + + +userdefined = IfcAirTerminalBoxTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalBoxTypeEnum.NOTDEFINED + + +IfcAirTerminalTypeEnum = enum_namespace() + + +diffuser = IfcAirTerminalTypeEnum.DIFFUSER + + +grille = IfcAirTerminalTypeEnum.GRILLE + + +louvre = IfcAirTerminalTypeEnum.LOUVRE + + +register = IfcAirTerminalTypeEnum.REGISTER + + +userdefined = IfcAirTerminalTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalTypeEnum.NOTDEFINED + + +IfcAirToAirHeatRecoveryTypeEnum = enum_namespace() + + +fixedplatecounterflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECOUNTERFLOWEXCHANGER + + +fixedplatecrossflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECROSSFLOWEXCHANGER + + +fixedplateparallelflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATEPARALLELFLOWEXCHANGER + + +heatpipe = IfcAirToAirHeatRecoveryTypeEnum.HEATPIPE + + +rotarywheel = IfcAirToAirHeatRecoveryTypeEnum.ROTARYWHEEL + + +runaroundcoilloop = IfcAirToAirHeatRecoveryTypeEnum.RUNAROUNDCOILLOOP + + +thermosiphoncoiltypeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONCOILTYPEHEATEXCHANGERS + + +thermosiphonsealedtubeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONSEALEDTUBEHEATEXCHANGERS + + +twintowerenthalpyrecoveryloops = IfcAirToAirHeatRecoveryTypeEnum.TWINTOWERENTHALPYRECOVERYLOOPS + + +userdefined = IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED + + +notdefined = IfcAirToAirHeatRecoveryTypeEnum.NOTDEFINED + + +IfcAlarmTypeEnum = enum_namespace() + + +bell = IfcAlarmTypeEnum.BELL + + +breakglassbutton = IfcAlarmTypeEnum.BREAKGLASSBUTTON + + +light = IfcAlarmTypeEnum.LIGHT + + +manualpullbox = IfcAlarmTypeEnum.MANUALPULLBOX + + +railwaycrocodile = IfcAlarmTypeEnum.RAILWAYCROCODILE + + +railwaydetonator = IfcAlarmTypeEnum.RAILWAYDETONATOR + + +siren = IfcAlarmTypeEnum.SIREN + + +whistle = IfcAlarmTypeEnum.WHISTLE + + +userdefined = IfcAlarmTypeEnum.USERDEFINED + + +notdefined = IfcAlarmTypeEnum.NOTDEFINED + + +IfcAlignmentCantSegmentTypeEnum = enum_namespace() + + +blosscurve = IfcAlignmentCantSegmentTypeEnum.BLOSSCURVE + + +constantcant = IfcAlignmentCantSegmentTypeEnum.CONSTANTCANT + + +cosinecurve = IfcAlignmentCantSegmentTypeEnum.COSINECURVE + + +helmertcurve = IfcAlignmentCantSegmentTypeEnum.HELMERTCURVE + + +lineartransition = IfcAlignmentCantSegmentTypeEnum.LINEARTRANSITION + + +sinecurve = IfcAlignmentCantSegmentTypeEnum.SINECURVE + + +viennesebend = IfcAlignmentCantSegmentTypeEnum.VIENNESEBEND + + +IfcAlignmentHorizontalSegmentTypeEnum = enum_namespace() + + +blosscurve = IfcAlignmentHorizontalSegmentTypeEnum.BLOSSCURVE + + +circulararc = IfcAlignmentHorizontalSegmentTypeEnum.CIRCULARARC + + +clothoid = IfcAlignmentHorizontalSegmentTypeEnum.CLOTHOID + + +cosinecurve = IfcAlignmentHorizontalSegmentTypeEnum.COSINECURVE + + +cubic = IfcAlignmentHorizontalSegmentTypeEnum.CUBIC + + +helmertcurve = IfcAlignmentHorizontalSegmentTypeEnum.HELMERTCURVE + + +line = IfcAlignmentHorizontalSegmentTypeEnum.LINE + + +sinecurve = IfcAlignmentHorizontalSegmentTypeEnum.SINECURVE + + +viennesebend = IfcAlignmentHorizontalSegmentTypeEnum.VIENNESEBEND + + +IfcAlignmentTypeEnum = enum_namespace() + + +userdefined = IfcAlignmentTypeEnum.USERDEFINED + + +notdefined = IfcAlignmentTypeEnum.NOTDEFINED + + +IfcAlignmentVerticalSegmentTypeEnum = enum_namespace() + + +circulararc = IfcAlignmentVerticalSegmentTypeEnum.CIRCULARARC + + +clothoid = IfcAlignmentVerticalSegmentTypeEnum.CLOTHOID + + +constantgradient = IfcAlignmentVerticalSegmentTypeEnum.CONSTANTGRADIENT + + +parabolicarc = IfcAlignmentVerticalSegmentTypeEnum.PARABOLICARC + + +IfcAnalysisModelTypeEnum = enum_namespace() + + +in_plane_loading_2d = IfcAnalysisModelTypeEnum.IN_PLANE_LOADING_2D + + +loading_3d = IfcAnalysisModelTypeEnum.LOADING_3D + + +out_plane_loading_2d = IfcAnalysisModelTypeEnum.OUT_PLANE_LOADING_2D + + +userdefined = IfcAnalysisModelTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisModelTypeEnum.NOTDEFINED + + +IfcAnalysisTheoryTypeEnum = enum_namespace() + + +first_order_theory = IfcAnalysisTheoryTypeEnum.FIRST_ORDER_THEORY + + +full_nonlinear_theory = IfcAnalysisTheoryTypeEnum.FULL_NONLINEAR_THEORY + + +second_order_theory = IfcAnalysisTheoryTypeEnum.SECOND_ORDER_THEORY + + +third_order_theory = IfcAnalysisTheoryTypeEnum.THIRD_ORDER_THEORY + + +userdefined = IfcAnalysisTheoryTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisTheoryTypeEnum.NOTDEFINED + + +IfcAnnotationTypeEnum = enum_namespace() + + +asbuiltarea = IfcAnnotationTypeEnum.ASBUILTAREA + + +asbuiltline = IfcAnnotationTypeEnum.ASBUILTLINE + + +asbuiltpoint = IfcAnnotationTypeEnum.ASBUILTPOINT + + +assumedarea = IfcAnnotationTypeEnum.ASSUMEDAREA + + +assumedline = IfcAnnotationTypeEnum.ASSUMEDLINE + + +assumedpoint = IfcAnnotationTypeEnum.ASSUMEDPOINT + + +non_physical_signal = IfcAnnotationTypeEnum.NON_PHYSICAL_SIGNAL + + +superelevationevent = IfcAnnotationTypeEnum.SUPERELEVATIONEVENT + + +widthevent = IfcAnnotationTypeEnum.WIDTHEVENT + + +userdefined = IfcAnnotationTypeEnum.USERDEFINED + + +notdefined = IfcAnnotationTypeEnum.NOTDEFINED + + +IfcArithmeticOperatorEnum = enum_namespace() + + +add = IfcArithmeticOperatorEnum.ADD + + +divide = IfcArithmeticOperatorEnum.DIVIDE + + +multiply = IfcArithmeticOperatorEnum.MULTIPLY + + +subtract = IfcArithmeticOperatorEnum.SUBTRACT + + +IfcAssemblyPlaceEnum = enum_namespace() + + +factory = IfcAssemblyPlaceEnum.FACTORY + + +site = IfcAssemblyPlaceEnum.SITE + + +notdefined = IfcAssemblyPlaceEnum.NOTDEFINED + + +IfcAudioVisualApplianceTypeEnum = enum_namespace() + + +amplifier = IfcAudioVisualApplianceTypeEnum.AMPLIFIER + + +camera = IfcAudioVisualApplianceTypeEnum.CAMERA + + +communicationterminal = IfcAudioVisualApplianceTypeEnum.COMMUNICATIONTERMINAL + + +display = IfcAudioVisualApplianceTypeEnum.DISPLAY + + +microphone = IfcAudioVisualApplianceTypeEnum.MICROPHONE + + +player = IfcAudioVisualApplianceTypeEnum.PLAYER + + +projector = IfcAudioVisualApplianceTypeEnum.PROJECTOR + + +receiver = IfcAudioVisualApplianceTypeEnum.RECEIVER + + +recordingequipment = IfcAudioVisualApplianceTypeEnum.RECORDINGEQUIPMENT + + +speaker = IfcAudioVisualApplianceTypeEnum.SPEAKER + + +switcher = IfcAudioVisualApplianceTypeEnum.SWITCHER + + +telephone = IfcAudioVisualApplianceTypeEnum.TELEPHONE + + +tuner = IfcAudioVisualApplianceTypeEnum.TUNER + + +userdefined = IfcAudioVisualApplianceTypeEnum.USERDEFINED + + +notdefined = IfcAudioVisualApplianceTypeEnum.NOTDEFINED + + +IfcBSplineCurveForm = enum_namespace() + + +circular_arc = IfcBSplineCurveForm.CIRCULAR_ARC + + +elliptic_arc = IfcBSplineCurveForm.ELLIPTIC_ARC + + +hyperbolic_arc = IfcBSplineCurveForm.HYPERBOLIC_ARC + + +parabolic_arc = IfcBSplineCurveForm.PARABOLIC_ARC + + +polyline_form = IfcBSplineCurveForm.POLYLINE_FORM + + +unspecified = IfcBSplineCurveForm.UNSPECIFIED + + +IfcBSplineSurfaceForm = enum_namespace() + + +conical_surf = IfcBSplineSurfaceForm.CONICAL_SURF + + +cylindrical_surf = IfcBSplineSurfaceForm.CYLINDRICAL_SURF + + +generalised_cone = IfcBSplineSurfaceForm.GENERALISED_CONE + + +plane_surf = IfcBSplineSurfaceForm.PLANE_SURF + + +quadric_surf = IfcBSplineSurfaceForm.QUADRIC_SURF + + +ruled_surf = IfcBSplineSurfaceForm.RULED_SURF + + +spherical_surf = IfcBSplineSurfaceForm.SPHERICAL_SURF + + +surf_of_linear_extrusion = IfcBSplineSurfaceForm.SURF_OF_LINEAR_EXTRUSION + + +surf_of_revolution = IfcBSplineSurfaceForm.SURF_OF_REVOLUTION + + +toroidal_surf = IfcBSplineSurfaceForm.TOROIDAL_SURF + + +unspecified = IfcBSplineSurfaceForm.UNSPECIFIED + + +IfcBeamTypeEnum = enum_namespace() + + +beam = IfcBeamTypeEnum.BEAM + + +cornice = IfcBeamTypeEnum.CORNICE + + +diaphragm = IfcBeamTypeEnum.DIAPHRAGM + + +edgebeam = IfcBeamTypeEnum.EDGEBEAM + + +girder_segment = IfcBeamTypeEnum.GIRDER_SEGMENT + + +hatstone = IfcBeamTypeEnum.HATSTONE + + +hollowcore = IfcBeamTypeEnum.HOLLOWCORE + + +joist = IfcBeamTypeEnum.JOIST + + +lintel = IfcBeamTypeEnum.LINTEL + + +piercap = IfcBeamTypeEnum.PIERCAP + + +spandrel = IfcBeamTypeEnum.SPANDREL + + +t_beam = IfcBeamTypeEnum.T_BEAM + + +userdefined = IfcBeamTypeEnum.USERDEFINED + + +notdefined = IfcBeamTypeEnum.NOTDEFINED + + +IfcBearingTypeDisplacementEnum = enum_namespace() + + +fixed_movement = IfcBearingTypeDisplacementEnum.FIXED_MOVEMENT + + +free_movement = IfcBearingTypeDisplacementEnum.FREE_MOVEMENT + + +guided_longitudinal = IfcBearingTypeDisplacementEnum.GUIDED_LONGITUDINAL + + +guided_transversal = IfcBearingTypeDisplacementEnum.GUIDED_TRANSVERSAL + + +notdefined = IfcBearingTypeDisplacementEnum.NOTDEFINED + + +IfcBearingTypeEnum = enum_namespace() + + +cylindrical = IfcBearingTypeEnum.CYLINDRICAL + + +disk = IfcBearingTypeEnum.DISK + + +elastomeric = IfcBearingTypeEnum.ELASTOMERIC + + +guide = IfcBearingTypeEnum.GUIDE + + +pot = IfcBearingTypeEnum.POT + + +rocker = IfcBearingTypeEnum.ROCKER + + +roller = IfcBearingTypeEnum.ROLLER + + +spherical = IfcBearingTypeEnum.SPHERICAL + + +userdefined = IfcBearingTypeEnum.USERDEFINED + + +notdefined = IfcBearingTypeEnum.NOTDEFINED + + +IfcBenchmarkEnum = enum_namespace() + + +equalto = IfcBenchmarkEnum.EQUALTO + + +greaterthan = IfcBenchmarkEnum.GREATERTHAN + + +greaterthanorequalto = IfcBenchmarkEnum.GREATERTHANOREQUALTO + + +includedin = IfcBenchmarkEnum.INCLUDEDIN + + +includes = IfcBenchmarkEnum.INCLUDES + + +lessthan = IfcBenchmarkEnum.LESSTHAN + + +lessthanorequalto = IfcBenchmarkEnum.LESSTHANOREQUALTO + + +notequalto = IfcBenchmarkEnum.NOTEQUALTO + + +notincludedin = IfcBenchmarkEnum.NOTINCLUDEDIN + + +notincludes = IfcBenchmarkEnum.NOTINCLUDES + + +IfcBoilerTypeEnum = enum_namespace() + + +steam = IfcBoilerTypeEnum.STEAM + + +water = IfcBoilerTypeEnum.WATER + + +userdefined = IfcBoilerTypeEnum.USERDEFINED + + +notdefined = IfcBoilerTypeEnum.NOTDEFINED + + +IfcBooleanOperator = enum_namespace() + + +difference = IfcBooleanOperator.DIFFERENCE + + +intersection = IfcBooleanOperator.INTERSECTION + + +union = IfcBooleanOperator.UNION + + +IfcBridgePartTypeEnum = enum_namespace() + + +abutment = IfcBridgePartTypeEnum.ABUTMENT + + +deck = IfcBridgePartTypeEnum.DECK + + +deck_segment = IfcBridgePartTypeEnum.DECK_SEGMENT + + +foundation = IfcBridgePartTypeEnum.FOUNDATION + + +pier = IfcBridgePartTypeEnum.PIER + + +pier_segment = IfcBridgePartTypeEnum.PIER_SEGMENT + + +pylon = IfcBridgePartTypeEnum.PYLON + + +substructure = IfcBridgePartTypeEnum.SUBSTRUCTURE + + +superstructure = IfcBridgePartTypeEnum.SUPERSTRUCTURE + + +surfacestructure = IfcBridgePartTypeEnum.SURFACESTRUCTURE + + +userdefined = IfcBridgePartTypeEnum.USERDEFINED + + +notdefined = IfcBridgePartTypeEnum.NOTDEFINED + + +IfcBridgeTypeEnum = enum_namespace() + + +arched = IfcBridgeTypeEnum.ARCHED + + +cable_stayed = IfcBridgeTypeEnum.CABLE_STAYED + + +cantilever = IfcBridgeTypeEnum.CANTILEVER + + +culvert = IfcBridgeTypeEnum.CULVERT + + +framework = IfcBridgeTypeEnum.FRAMEWORK + + +girder = IfcBridgeTypeEnum.GIRDER + + +suspension = IfcBridgeTypeEnum.SUSPENSION + + +truss = IfcBridgeTypeEnum.TRUSS + + +userdefined = IfcBridgeTypeEnum.USERDEFINED + + +notdefined = IfcBridgeTypeEnum.NOTDEFINED + + +IfcBuildingElementPartTypeEnum = enum_namespace() + + +apron = IfcBuildingElementPartTypeEnum.APRON + + +armourunit = IfcBuildingElementPartTypeEnum.ARMOURUNIT + + +insulation = IfcBuildingElementPartTypeEnum.INSULATION + + +precastpanel = IfcBuildingElementPartTypeEnum.PRECASTPANEL + + +safetycage = IfcBuildingElementPartTypeEnum.SAFETYCAGE + + +userdefined = IfcBuildingElementPartTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementPartTypeEnum.NOTDEFINED + + +IfcBuildingElementProxyTypeEnum = enum_namespace() + + +complex = IfcBuildingElementProxyTypeEnum.COMPLEX + + +element = IfcBuildingElementProxyTypeEnum.ELEMENT + + +partial = IfcBuildingElementProxyTypeEnum.PARTIAL + + +userdefined = IfcBuildingElementProxyTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementProxyTypeEnum.NOTDEFINED + + +IfcBuildingSystemTypeEnum = enum_namespace() + + +erosionprevention = IfcBuildingSystemTypeEnum.EROSIONPREVENTION + + +fenestration = IfcBuildingSystemTypeEnum.FENESTRATION + + +foundation = IfcBuildingSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuildingSystemTypeEnum.LOADBEARING + + +outershell = IfcBuildingSystemTypeEnum.OUTERSHELL + + +prestressing = IfcBuildingSystemTypeEnum.PRESTRESSING + + +reinforcing = IfcBuildingSystemTypeEnum.REINFORCING + + +shading = IfcBuildingSystemTypeEnum.SHADING + + +transport = IfcBuildingSystemTypeEnum.TRANSPORT + + +userdefined = IfcBuildingSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuildingSystemTypeEnum.NOTDEFINED + + +IfcBuiltSystemTypeEnum = enum_namespace() + + +erosionprevention = IfcBuiltSystemTypeEnum.EROSIONPREVENTION + + +fenestration = IfcBuiltSystemTypeEnum.FENESTRATION + + +foundation = IfcBuiltSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuiltSystemTypeEnum.LOADBEARING + + +mooring = IfcBuiltSystemTypeEnum.MOORING + + +outershell = IfcBuiltSystemTypeEnum.OUTERSHELL + + +prestressing = IfcBuiltSystemTypeEnum.PRESTRESSING + + +railwayline = IfcBuiltSystemTypeEnum.RAILWAYLINE + + +railwaytrack = IfcBuiltSystemTypeEnum.RAILWAYTRACK + + +reinforcing = IfcBuiltSystemTypeEnum.REINFORCING + + +shading = IfcBuiltSystemTypeEnum.SHADING + + +trackcircuit = IfcBuiltSystemTypeEnum.TRACKCIRCUIT + + +transport = IfcBuiltSystemTypeEnum.TRANSPORT + + +userdefined = IfcBuiltSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuiltSystemTypeEnum.NOTDEFINED + + +IfcBurnerTypeEnum = enum_namespace() + + +userdefined = IfcBurnerTypeEnum.USERDEFINED + + +notdefined = IfcBurnerTypeEnum.NOTDEFINED + + +IfcCableCarrierFittingTypeEnum = enum_namespace() + + +bend = IfcCableCarrierFittingTypeEnum.BEND + + +connector = IfcCableCarrierFittingTypeEnum.CONNECTOR + + +cross = IfcCableCarrierFittingTypeEnum.CROSS + + +junction = IfcCableCarrierFittingTypeEnum.JUNCTION + + +tee = IfcCableCarrierFittingTypeEnum.TEE + + +transition = IfcCableCarrierFittingTypeEnum.TRANSITION + + +userdefined = IfcCableCarrierFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierFittingTypeEnum.NOTDEFINED + + +IfcCableCarrierSegmentTypeEnum = enum_namespace() + + +cablebracket = IfcCableCarrierSegmentTypeEnum.CABLEBRACKET + + +cableladdersegment = IfcCableCarrierSegmentTypeEnum.CABLELADDERSEGMENT + + +cabletraysegment = IfcCableCarrierSegmentTypeEnum.CABLETRAYSEGMENT + + +cabletrunkingsegment = IfcCableCarrierSegmentTypeEnum.CABLETRUNKINGSEGMENT + + +catenarywire = IfcCableCarrierSegmentTypeEnum.CATENARYWIRE + + +conduitsegment = IfcCableCarrierSegmentTypeEnum.CONDUITSEGMENT + + +dropper = IfcCableCarrierSegmentTypeEnum.DROPPER + + +userdefined = IfcCableCarrierSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierSegmentTypeEnum.NOTDEFINED + + +IfcCableFittingTypeEnum = enum_namespace() + + +connector = IfcCableFittingTypeEnum.CONNECTOR + + +entry = IfcCableFittingTypeEnum.ENTRY + + +exit = IfcCableFittingTypeEnum.EXIT + + +fanout = IfcCableFittingTypeEnum.FANOUT + + +junction = IfcCableFittingTypeEnum.JUNCTION + + +transition = IfcCableFittingTypeEnum.TRANSITION + + +userdefined = IfcCableFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableFittingTypeEnum.NOTDEFINED + + +IfcCableSegmentTypeEnum = enum_namespace() + + +busbarsegment = IfcCableSegmentTypeEnum.BUSBARSEGMENT + + +cablesegment = IfcCableSegmentTypeEnum.CABLESEGMENT + + +conductorsegment = IfcCableSegmentTypeEnum.CONDUCTORSEGMENT + + +contactwiresegment = IfcCableSegmentTypeEnum.CONTACTWIRESEGMENT + + +coresegment = IfcCableSegmentTypeEnum.CORESEGMENT + + +fibersegment = IfcCableSegmentTypeEnum.FIBERSEGMENT + + +fibertube = IfcCableSegmentTypeEnum.FIBERTUBE + + +opticalcablesegment = IfcCableSegmentTypeEnum.OPTICALCABLESEGMENT + + +stitchwire = IfcCableSegmentTypeEnum.STITCHWIRE + + +wirepairsegment = IfcCableSegmentTypeEnum.WIREPAIRSEGMENT + + +userdefined = IfcCableSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableSegmentTypeEnum.NOTDEFINED + + +IfcCaissonFoundationTypeEnum = enum_namespace() + + +caisson = IfcCaissonFoundationTypeEnum.CAISSON + + +well = IfcCaissonFoundationTypeEnum.WELL + + +userdefined = IfcCaissonFoundationTypeEnum.USERDEFINED + + +notdefined = IfcCaissonFoundationTypeEnum.NOTDEFINED + + +IfcChangeActionEnum = enum_namespace() + + +added = IfcChangeActionEnum.ADDED + + +deleted = IfcChangeActionEnum.DELETED + + +modified = IfcChangeActionEnum.MODIFIED + + +nochange = IfcChangeActionEnum.NOCHANGE + + +notdefined = IfcChangeActionEnum.NOTDEFINED + + +IfcChillerTypeEnum = enum_namespace() + + +aircooled = IfcChillerTypeEnum.AIRCOOLED + + +heatrecovery = IfcChillerTypeEnum.HEATRECOVERY + + +watercooled = IfcChillerTypeEnum.WATERCOOLED + + +userdefined = IfcChillerTypeEnum.USERDEFINED + + +notdefined = IfcChillerTypeEnum.NOTDEFINED + + +IfcChimneyTypeEnum = enum_namespace() + + +userdefined = IfcChimneyTypeEnum.USERDEFINED + + +notdefined = IfcChimneyTypeEnum.NOTDEFINED + + +IfcCoilTypeEnum = enum_namespace() + + +dxcoolingcoil = IfcCoilTypeEnum.DXCOOLINGCOIL + + +electricheatingcoil = IfcCoilTypeEnum.ELECTRICHEATINGCOIL + + +gasheatingcoil = IfcCoilTypeEnum.GASHEATINGCOIL + + +hydroniccoil = IfcCoilTypeEnum.HYDRONICCOIL + + +steamheatingcoil = IfcCoilTypeEnum.STEAMHEATINGCOIL + + +watercoolingcoil = IfcCoilTypeEnum.WATERCOOLINGCOIL + + +waterheatingcoil = IfcCoilTypeEnum.WATERHEATINGCOIL + + +userdefined = IfcCoilTypeEnum.USERDEFINED + + +notdefined = IfcCoilTypeEnum.NOTDEFINED + + +IfcColumnTypeEnum = enum_namespace() + + +column = IfcColumnTypeEnum.COLUMN + + +pierstem = IfcColumnTypeEnum.PIERSTEM + + +pierstem_segment = IfcColumnTypeEnum.PIERSTEM_SEGMENT + + +pilaster = IfcColumnTypeEnum.PILASTER + + +standcolumn = IfcColumnTypeEnum.STANDCOLUMN + + +userdefined = IfcColumnTypeEnum.USERDEFINED + + +notdefined = IfcColumnTypeEnum.NOTDEFINED + + +IfcCommunicationsApplianceTypeEnum = enum_namespace() + + +antenna = IfcCommunicationsApplianceTypeEnum.ANTENNA + + +automaton = IfcCommunicationsApplianceTypeEnum.AUTOMATON + + +computer = IfcCommunicationsApplianceTypeEnum.COMPUTER + + +fax = IfcCommunicationsApplianceTypeEnum.FAX + + +gateway = IfcCommunicationsApplianceTypeEnum.GATEWAY + + +intelligentperipheral = IfcCommunicationsApplianceTypeEnum.INTELLIGENTPERIPHERAL + + +ipnetworkequipment = IfcCommunicationsApplianceTypeEnum.IPNETWORKEQUIPMENT + + +linesideelectronicunit = IfcCommunicationsApplianceTypeEnum.LINESIDEELECTRONICUNIT + + +modem = IfcCommunicationsApplianceTypeEnum.MODEM + + +networkappliance = IfcCommunicationsApplianceTypeEnum.NETWORKAPPLIANCE + + +networkbridge = IfcCommunicationsApplianceTypeEnum.NETWORKBRIDGE + + +networkhub = IfcCommunicationsApplianceTypeEnum.NETWORKHUB + + +opticallineterminal = IfcCommunicationsApplianceTypeEnum.OPTICALLINETERMINAL + + +opticalnetworkunit = IfcCommunicationsApplianceTypeEnum.OPTICALNETWORKUNIT + + +printer = IfcCommunicationsApplianceTypeEnum.PRINTER + + +radioblockcenter = IfcCommunicationsApplianceTypeEnum.RADIOBLOCKCENTER + + +repeater = IfcCommunicationsApplianceTypeEnum.REPEATER + + +router = IfcCommunicationsApplianceTypeEnum.ROUTER + + +scanner = IfcCommunicationsApplianceTypeEnum.SCANNER + + +telecommand = IfcCommunicationsApplianceTypeEnum.TELECOMMAND + + +telephonyexchange = IfcCommunicationsApplianceTypeEnum.TELEPHONYEXCHANGE + + +transitioncomponent = IfcCommunicationsApplianceTypeEnum.TRANSITIONCOMPONENT + + +transponder = IfcCommunicationsApplianceTypeEnum.TRANSPONDER + + +transportequipment = IfcCommunicationsApplianceTypeEnum.TRANSPORTEQUIPMENT + + +userdefined = IfcCommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcCommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcComplexPropertyTemplateTypeEnum = enum_namespace() + + +p_complex = IfcComplexPropertyTemplateTypeEnum.P_COMPLEX + + +q_complex = IfcComplexPropertyTemplateTypeEnum.Q_COMPLEX + + +IfcCompressorTypeEnum = enum_namespace() + + +booster = IfcCompressorTypeEnum.BOOSTER + + +dynamic = IfcCompressorTypeEnum.DYNAMIC + + +hermetic = IfcCompressorTypeEnum.HERMETIC + + +opentype = IfcCompressorTypeEnum.OPENTYPE + + +reciprocating = IfcCompressorTypeEnum.RECIPROCATING + + +rollingpiston = IfcCompressorTypeEnum.ROLLINGPISTON + + +rotary = IfcCompressorTypeEnum.ROTARY + + +rotaryvane = IfcCompressorTypeEnum.ROTARYVANE + + +scroll = IfcCompressorTypeEnum.SCROLL + + +semihermetic = IfcCompressorTypeEnum.SEMIHERMETIC + + +singlescrew = IfcCompressorTypeEnum.SINGLESCREW + + +singlestage = IfcCompressorTypeEnum.SINGLESTAGE + + +trochoidal = IfcCompressorTypeEnum.TROCHOIDAL + + +twinscrew = IfcCompressorTypeEnum.TWINSCREW + + +weldedshellhermetic = IfcCompressorTypeEnum.WELDEDSHELLHERMETIC + + +userdefined = IfcCompressorTypeEnum.USERDEFINED + + +notdefined = IfcCompressorTypeEnum.NOTDEFINED + + +IfcCondenserTypeEnum = enum_namespace() + + +aircooled = IfcCondenserTypeEnum.AIRCOOLED + + +evaporativecooled = IfcCondenserTypeEnum.EVAPORATIVECOOLED + + +watercooled = IfcCondenserTypeEnum.WATERCOOLED + + +watercooledbrazedplate = IfcCondenserTypeEnum.WATERCOOLEDBRAZEDPLATE + + +watercooledshellcoil = IfcCondenserTypeEnum.WATERCOOLEDSHELLCOIL + + +watercooledshelltube = IfcCondenserTypeEnum.WATERCOOLEDSHELLTUBE + + +watercooledtubeintube = IfcCondenserTypeEnum.WATERCOOLEDTUBEINTUBE + + +userdefined = IfcCondenserTypeEnum.USERDEFINED + + +notdefined = IfcCondenserTypeEnum.NOTDEFINED + + +IfcConnectionTypeEnum = enum_namespace() + + +atend = IfcConnectionTypeEnum.ATEND + + +atpath = IfcConnectionTypeEnum.ATPATH + + +atstart = IfcConnectionTypeEnum.ATSTART + + +notdefined = IfcConnectionTypeEnum.NOTDEFINED + + +IfcConstraintEnum = enum_namespace() + + +advisory = IfcConstraintEnum.ADVISORY + + +hard = IfcConstraintEnum.HARD + + +soft = IfcConstraintEnum.SOFT + + +userdefined = IfcConstraintEnum.USERDEFINED + + +notdefined = IfcConstraintEnum.NOTDEFINED + + +IfcConstructionEquipmentResourceTypeEnum = enum_namespace() + + +demolishing = IfcConstructionEquipmentResourceTypeEnum.DEMOLISHING + + +earthmoving = IfcConstructionEquipmentResourceTypeEnum.EARTHMOVING + + +erecting = IfcConstructionEquipmentResourceTypeEnum.ERECTING + + +heating = IfcConstructionEquipmentResourceTypeEnum.HEATING + + +lighting = IfcConstructionEquipmentResourceTypeEnum.LIGHTING + + +paving = IfcConstructionEquipmentResourceTypeEnum.PAVING + + +pumping = IfcConstructionEquipmentResourceTypeEnum.PUMPING + + +transporting = IfcConstructionEquipmentResourceTypeEnum.TRANSPORTING + + +userdefined = IfcConstructionEquipmentResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionEquipmentResourceTypeEnum.NOTDEFINED + + +IfcConstructionMaterialResourceTypeEnum = enum_namespace() + + +aggregates = IfcConstructionMaterialResourceTypeEnum.AGGREGATES + + +concrete = IfcConstructionMaterialResourceTypeEnum.CONCRETE + + +drywall = IfcConstructionMaterialResourceTypeEnum.DRYWALL + + +fuel = IfcConstructionMaterialResourceTypeEnum.FUEL + + +gypsum = IfcConstructionMaterialResourceTypeEnum.GYPSUM + + +masonry = IfcConstructionMaterialResourceTypeEnum.MASONRY + + +metal = IfcConstructionMaterialResourceTypeEnum.METAL + + +plastic = IfcConstructionMaterialResourceTypeEnum.PLASTIC + + +wood = IfcConstructionMaterialResourceTypeEnum.WOOD + + +userdefined = IfcConstructionMaterialResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionMaterialResourceTypeEnum.NOTDEFINED + + +IfcConstructionProductResourceTypeEnum = enum_namespace() + + +assembly = IfcConstructionProductResourceTypeEnum.ASSEMBLY + + +formwork = IfcConstructionProductResourceTypeEnum.FORMWORK + + +userdefined = IfcConstructionProductResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionProductResourceTypeEnum.NOTDEFINED + + +IfcControllerTypeEnum = enum_namespace() + + +floating = IfcControllerTypeEnum.FLOATING + + +multiposition = IfcControllerTypeEnum.MULTIPOSITION + + +programmable = IfcControllerTypeEnum.PROGRAMMABLE + + +proportional = IfcControllerTypeEnum.PROPORTIONAL + + +twoposition = IfcControllerTypeEnum.TWOPOSITION + + +userdefined = IfcControllerTypeEnum.USERDEFINED + + +notdefined = IfcControllerTypeEnum.NOTDEFINED + + +IfcConveyorSegmentTypeEnum = enum_namespace() + + +beltconveyor = IfcConveyorSegmentTypeEnum.BELTCONVEYOR + + +bucketconveyor = IfcConveyorSegmentTypeEnum.BUCKETCONVEYOR + + +chuteconveyor = IfcConveyorSegmentTypeEnum.CHUTECONVEYOR + + +screwconveyor = IfcConveyorSegmentTypeEnum.SCREWCONVEYOR + + +userdefined = IfcConveyorSegmentTypeEnum.USERDEFINED + + +notdefined = IfcConveyorSegmentTypeEnum.NOTDEFINED + + +IfcCooledBeamTypeEnum = enum_namespace() + + +active = IfcCooledBeamTypeEnum.ACTIVE + + +passive = IfcCooledBeamTypeEnum.PASSIVE + + +userdefined = IfcCooledBeamTypeEnum.USERDEFINED + + +notdefined = IfcCooledBeamTypeEnum.NOTDEFINED + + +IfcCoolingTowerTypeEnum = enum_namespace() + + +mechanicalforceddraft = IfcCoolingTowerTypeEnum.MECHANICALFORCEDDRAFT + + +mechanicalinduceddraft = IfcCoolingTowerTypeEnum.MECHANICALINDUCEDDRAFT + + +naturaldraft = IfcCoolingTowerTypeEnum.NATURALDRAFT + + +userdefined = IfcCoolingTowerTypeEnum.USERDEFINED + + +notdefined = IfcCoolingTowerTypeEnum.NOTDEFINED + + +IfcCostItemTypeEnum = enum_namespace() + + +userdefined = IfcCostItemTypeEnum.USERDEFINED + + +notdefined = IfcCostItemTypeEnum.NOTDEFINED + + +IfcCostScheduleTypeEnum = enum_namespace() + + +budget = IfcCostScheduleTypeEnum.BUDGET + + +costplan = IfcCostScheduleTypeEnum.COSTPLAN + + +estimate = IfcCostScheduleTypeEnum.ESTIMATE + + +pricedbillofquantities = IfcCostScheduleTypeEnum.PRICEDBILLOFQUANTITIES + + +scheduleofrates = IfcCostScheduleTypeEnum.SCHEDULEOFRATES + + +tender = IfcCostScheduleTypeEnum.TENDER + + +unpricedbillofquantities = IfcCostScheduleTypeEnum.UNPRICEDBILLOFQUANTITIES + + +userdefined = IfcCostScheduleTypeEnum.USERDEFINED + + +notdefined = IfcCostScheduleTypeEnum.NOTDEFINED + + +IfcCourseTypeEnum = enum_namespace() + + +armour = IfcCourseTypeEnum.ARMOUR + + +ballastbed = IfcCourseTypeEnum.BALLASTBED + + +core = IfcCourseTypeEnum.CORE + + +filter = IfcCourseTypeEnum.FILTER + + +pavement = IfcCourseTypeEnum.PAVEMENT + + +protection = IfcCourseTypeEnum.PROTECTION + + +userdefined = IfcCourseTypeEnum.USERDEFINED + + +notdefined = IfcCourseTypeEnum.NOTDEFINED + + +IfcCoveringTypeEnum = enum_namespace() + + +ceiling = IfcCoveringTypeEnum.CEILING + + +cladding = IfcCoveringTypeEnum.CLADDING + + +coping = IfcCoveringTypeEnum.COPING + + +flooring = IfcCoveringTypeEnum.FLOORING + + +insulation = IfcCoveringTypeEnum.INSULATION + + +membrane = IfcCoveringTypeEnum.MEMBRANE + + +molding = IfcCoveringTypeEnum.MOLDING + + +roofing = IfcCoveringTypeEnum.ROOFING + + +skirtingboard = IfcCoveringTypeEnum.SKIRTINGBOARD + + +sleeving = IfcCoveringTypeEnum.SLEEVING + + +topping = IfcCoveringTypeEnum.TOPPING + + +wrapping = IfcCoveringTypeEnum.WRAPPING + + +userdefined = IfcCoveringTypeEnum.USERDEFINED + + +notdefined = IfcCoveringTypeEnum.NOTDEFINED + + +IfcCrewResourceTypeEnum = enum_namespace() + + +office = IfcCrewResourceTypeEnum.OFFICE + + +site = IfcCrewResourceTypeEnum.SITE + + +userdefined = IfcCrewResourceTypeEnum.USERDEFINED + + +notdefined = IfcCrewResourceTypeEnum.NOTDEFINED + + +IfcCurtainWallTypeEnum = enum_namespace() + + +userdefined = IfcCurtainWallTypeEnum.USERDEFINED + + +notdefined = IfcCurtainWallTypeEnum.NOTDEFINED + + +IfcCurveInterpolationEnum = enum_namespace() + + +linear = IfcCurveInterpolationEnum.LINEAR + + +log_linear = IfcCurveInterpolationEnum.LOG_LINEAR + + +log_log = IfcCurveInterpolationEnum.LOG_LOG + + +notdefined = IfcCurveInterpolationEnum.NOTDEFINED + + +IfcDamperTypeEnum = enum_namespace() + + +backdraftdamper = IfcDamperTypeEnum.BACKDRAFTDAMPER + + +balancingdamper = IfcDamperTypeEnum.BALANCINGDAMPER + + +blastdamper = IfcDamperTypeEnum.BLASTDAMPER + + +controldamper = IfcDamperTypeEnum.CONTROLDAMPER + + +firedamper = IfcDamperTypeEnum.FIREDAMPER + + +firesmokedamper = IfcDamperTypeEnum.FIRESMOKEDAMPER + + +fumehoodexhaust = IfcDamperTypeEnum.FUMEHOODEXHAUST + + +gravitydamper = IfcDamperTypeEnum.GRAVITYDAMPER + + +gravityreliefdamper = IfcDamperTypeEnum.GRAVITYRELIEFDAMPER + + +reliefdamper = IfcDamperTypeEnum.RELIEFDAMPER + + +smokedamper = IfcDamperTypeEnum.SMOKEDAMPER + + +userdefined = IfcDamperTypeEnum.USERDEFINED + + +notdefined = IfcDamperTypeEnum.NOTDEFINED + + +IfcDataOriginEnum = enum_namespace() + + +measured = IfcDataOriginEnum.MEASURED + + +predicted = IfcDataOriginEnum.PREDICTED + + +simulated = IfcDataOriginEnum.SIMULATED + + +userdefined = IfcDataOriginEnum.USERDEFINED + + +notdefined = IfcDataOriginEnum.NOTDEFINED + + +IfcDerivedUnitEnum = enum_namespace() + + +accelerationunit = IfcDerivedUnitEnum.ACCELERATIONUNIT + + +angularvelocityunit = IfcDerivedUnitEnum.ANGULARVELOCITYUNIT + + +areadensityunit = IfcDerivedUnitEnum.AREADENSITYUNIT + + +compoundplaneangleunit = IfcDerivedUnitEnum.COMPOUNDPLANEANGLEUNIT + + +curvatureunit = IfcDerivedUnitEnum.CURVATUREUNIT + + +dynamicviscosityunit = IfcDerivedUnitEnum.DYNAMICVISCOSITYUNIT + + +heatfluxdensityunit = IfcDerivedUnitEnum.HEATFLUXDENSITYUNIT + + +heatingvalueunit = IfcDerivedUnitEnum.HEATINGVALUEUNIT + + +integercountrateunit = IfcDerivedUnitEnum.INTEGERCOUNTRATEUNIT + + +ionconcentrationunit = IfcDerivedUnitEnum.IONCONCENTRATIONUNIT + + +isothermalmoisturecapacityunit = IfcDerivedUnitEnum.ISOTHERMALMOISTURECAPACITYUNIT + + +kinematicviscosityunit = IfcDerivedUnitEnum.KINEMATICVISCOSITYUNIT + + +linearforceunit = IfcDerivedUnitEnum.LINEARFORCEUNIT + + +linearmomentunit = IfcDerivedUnitEnum.LINEARMOMENTUNIT + + +linearstiffnessunit = IfcDerivedUnitEnum.LINEARSTIFFNESSUNIT + + +linearvelocityunit = IfcDerivedUnitEnum.LINEARVELOCITYUNIT + + +luminousintensitydistributionunit = IfcDerivedUnitEnum.LUMINOUSINTENSITYDISTRIBUTIONUNIT + + +massdensityunit = IfcDerivedUnitEnum.MASSDENSITYUNIT + + +massflowrateunit = IfcDerivedUnitEnum.MASSFLOWRATEUNIT + + +massperlengthunit = IfcDerivedUnitEnum.MASSPERLENGTHUNIT + + +modulusofelasticityunit = IfcDerivedUnitEnum.MODULUSOFELASTICITYUNIT + + +modulusoflinearsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFLINEARSUBGRADEREACTIONUNIT + + +modulusofrotationalsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFROTATIONALSUBGRADEREACTIONUNIT + + +modulusofsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFSUBGRADEREACTIONUNIT + + +moisturediffusivityunit = IfcDerivedUnitEnum.MOISTUREDIFFUSIVITYUNIT + + +molecularweightunit = IfcDerivedUnitEnum.MOLECULARWEIGHTUNIT + + +momentofinertiaunit = IfcDerivedUnitEnum.MOMENTOFINERTIAUNIT + + +phunit = IfcDerivedUnitEnum.PHUNIT + + +planarforceunit = IfcDerivedUnitEnum.PLANARFORCEUNIT + + +rotationalfrequencyunit = IfcDerivedUnitEnum.ROTATIONALFREQUENCYUNIT + + +rotationalmassunit = IfcDerivedUnitEnum.ROTATIONALMASSUNIT + + +rotationalstiffnessunit = IfcDerivedUnitEnum.ROTATIONALSTIFFNESSUNIT + + +sectionareaintegralunit = IfcDerivedUnitEnum.SECTIONAREAINTEGRALUNIT + + +sectionmodulusunit = IfcDerivedUnitEnum.SECTIONMODULUSUNIT + + +shearmodulusunit = IfcDerivedUnitEnum.SHEARMODULUSUNIT + + +soundpowerlevelunit = IfcDerivedUnitEnum.SOUNDPOWERLEVELUNIT + + +soundpowerunit = IfcDerivedUnitEnum.SOUNDPOWERUNIT + + +soundpressurelevelunit = IfcDerivedUnitEnum.SOUNDPRESSURELEVELUNIT + + +soundpressureunit = IfcDerivedUnitEnum.SOUNDPRESSUREUNIT + + +specificheatcapacityunit = IfcDerivedUnitEnum.SPECIFICHEATCAPACITYUNIT + + +temperaturegradientunit = IfcDerivedUnitEnum.TEMPERATUREGRADIENTUNIT + + +temperaturerateofchangeunit = IfcDerivedUnitEnum.TEMPERATURERATEOFCHANGEUNIT + + +thermaladmittanceunit = IfcDerivedUnitEnum.THERMALADMITTANCEUNIT + + +thermalconductanceunit = IfcDerivedUnitEnum.THERMALCONDUCTANCEUNIT + + +thermalexpansioncoefficientunit = IfcDerivedUnitEnum.THERMALEXPANSIONCOEFFICIENTUNIT + + +thermalresistanceunit = IfcDerivedUnitEnum.THERMALRESISTANCEUNIT + + +thermaltransmittanceunit = IfcDerivedUnitEnum.THERMALTRANSMITTANCEUNIT + + +torqueunit = IfcDerivedUnitEnum.TORQUEUNIT + + +vaporpermeabilityunit = IfcDerivedUnitEnum.VAPORPERMEABILITYUNIT + + +volumetricflowrateunit = IfcDerivedUnitEnum.VOLUMETRICFLOWRATEUNIT + + +warpingconstantunit = IfcDerivedUnitEnum.WARPINGCONSTANTUNIT + + +warpingmomentunit = IfcDerivedUnitEnum.WARPINGMOMENTUNIT + + +userdefined = IfcDerivedUnitEnum.USERDEFINED + + +IfcDirectionSenseEnum = enum_namespace() + + +negative = IfcDirectionSenseEnum.NEGATIVE + + +positive = IfcDirectionSenseEnum.POSITIVE + + +IfcDiscreteAccessoryTypeEnum = enum_namespace() + + +anchorplate = IfcDiscreteAccessoryTypeEnum.ANCHORPLATE + + +birdprotection = IfcDiscreteAccessoryTypeEnum.BIRDPROTECTION + + +bracket = IfcDiscreteAccessoryTypeEnum.BRACKET + + +cablearranger = IfcDiscreteAccessoryTypeEnum.CABLEARRANGER + + +elastic_cushion = IfcDiscreteAccessoryTypeEnum.ELASTIC_CUSHION + + +expansion_joint_device = IfcDiscreteAccessoryTypeEnum.EXPANSION_JOINT_DEVICE + + +filler = IfcDiscreteAccessoryTypeEnum.FILLER + + +flashing = IfcDiscreteAccessoryTypeEnum.FLASHING + + +insulator = IfcDiscreteAccessoryTypeEnum.INSULATOR + + +lock = IfcDiscreteAccessoryTypeEnum.LOCK + + +panel_strengthening = IfcDiscreteAccessoryTypeEnum.PANEL_STRENGTHENING + + +pointmachinemountingdevice = IfcDiscreteAccessoryTypeEnum.POINTMACHINEMOUNTINGDEVICE + + +point_machine_locking_device = IfcDiscreteAccessoryTypeEnum.POINT_MACHINE_LOCKING_DEVICE + + +railbrace = IfcDiscreteAccessoryTypeEnum.RAILBRACE + + +railpad = IfcDiscreteAccessoryTypeEnum.RAILPAD + + +rail_lubrication = IfcDiscreteAccessoryTypeEnum.RAIL_LUBRICATION + + +rail_mechanical_equipment = IfcDiscreteAccessoryTypeEnum.RAIL_MECHANICAL_EQUIPMENT + + +shoe = IfcDiscreteAccessoryTypeEnum.SHOE + + +slidingchair = IfcDiscreteAccessoryTypeEnum.SLIDINGCHAIR + + +soundabsorption = IfcDiscreteAccessoryTypeEnum.SOUNDABSORPTION + + +tensioningequipment = IfcDiscreteAccessoryTypeEnum.TENSIONINGEQUIPMENT + + +userdefined = IfcDiscreteAccessoryTypeEnum.USERDEFINED + + +notdefined = IfcDiscreteAccessoryTypeEnum.NOTDEFINED + + +IfcDistributionBoardTypeEnum = enum_namespace() + + +consumerunit = IfcDistributionBoardTypeEnum.CONSUMERUNIT + + +dispatchingboard = IfcDistributionBoardTypeEnum.DISPATCHINGBOARD + + +distributionboard = IfcDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +distributionframe = IfcDistributionBoardTypeEnum.DISTRIBUTIONFRAME + + +motorcontrolcentre = IfcDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +switchboard = IfcDistributionBoardTypeEnum.SWITCHBOARD + + +userdefined = IfcDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcDistributionBoardTypeEnum.NOTDEFINED + + +IfcDistributionChamberElementTypeEnum = enum_namespace() + + +formedduct = IfcDistributionChamberElementTypeEnum.FORMEDDUCT + + +inspectionchamber = IfcDistributionChamberElementTypeEnum.INSPECTIONCHAMBER + + +inspectionpit = IfcDistributionChamberElementTypeEnum.INSPECTIONPIT + + +manhole = IfcDistributionChamberElementTypeEnum.MANHOLE + + +meterchamber = IfcDistributionChamberElementTypeEnum.METERCHAMBER + + +sump = IfcDistributionChamberElementTypeEnum.SUMP + + +trench = IfcDistributionChamberElementTypeEnum.TRENCH + + +valvechamber = IfcDistributionChamberElementTypeEnum.VALVECHAMBER + + +userdefined = IfcDistributionChamberElementTypeEnum.USERDEFINED + + +notdefined = IfcDistributionChamberElementTypeEnum.NOTDEFINED + + +IfcDistributionPortTypeEnum = enum_namespace() + + +cable = IfcDistributionPortTypeEnum.CABLE + + +cablecarrier = IfcDistributionPortTypeEnum.CABLECARRIER + + +duct = IfcDistributionPortTypeEnum.DUCT + + +pipe = IfcDistributionPortTypeEnum.PIPE + + +wireless = IfcDistributionPortTypeEnum.WIRELESS + + +userdefined = IfcDistributionPortTypeEnum.USERDEFINED + + +notdefined = IfcDistributionPortTypeEnum.NOTDEFINED + + +IfcDistributionSystemEnum = enum_namespace() + + +airconditioning = IfcDistributionSystemEnum.AIRCONDITIONING + + +audiovisual = IfcDistributionSystemEnum.AUDIOVISUAL + + +catenary_system = IfcDistributionSystemEnum.CATENARY_SYSTEM + + +chemical = IfcDistributionSystemEnum.CHEMICAL + + +chilledwater = IfcDistributionSystemEnum.CHILLEDWATER + + +communication = IfcDistributionSystemEnum.COMMUNICATION + + +compressedair = IfcDistributionSystemEnum.COMPRESSEDAIR + + +condenserwater = IfcDistributionSystemEnum.CONDENSERWATER + + +control = IfcDistributionSystemEnum.CONTROL + + +conveying = IfcDistributionSystemEnum.CONVEYING + + +data = IfcDistributionSystemEnum.DATA + + +disposal = IfcDistributionSystemEnum.DISPOSAL + + +domesticcoldwater = IfcDistributionSystemEnum.DOMESTICCOLDWATER + + +domestichotwater = IfcDistributionSystemEnum.DOMESTICHOTWATER + + +drainage = IfcDistributionSystemEnum.DRAINAGE + + +earthing = IfcDistributionSystemEnum.EARTHING + + +electrical = IfcDistributionSystemEnum.ELECTRICAL + + +electroacoustic = IfcDistributionSystemEnum.ELECTROACOUSTIC + + +exhaust = IfcDistributionSystemEnum.EXHAUST + + +fireprotection = IfcDistributionSystemEnum.FIREPROTECTION + + +fixedtransmissionnetwork = IfcDistributionSystemEnum.FIXEDTRANSMISSIONNETWORK + + +fuel = IfcDistributionSystemEnum.FUEL + + +gas = IfcDistributionSystemEnum.GAS + + +hazardous = IfcDistributionSystemEnum.HAZARDOUS + + +heating = IfcDistributionSystemEnum.HEATING + + +lighting = IfcDistributionSystemEnum.LIGHTING + + +lightningprotection = IfcDistributionSystemEnum.LIGHTNINGPROTECTION + + +mobilenetwork = IfcDistributionSystemEnum.MOBILENETWORK + + +monitoringsystem = IfcDistributionSystemEnum.MONITORINGSYSTEM + + +municipalsolidwaste = IfcDistributionSystemEnum.MUNICIPALSOLIDWASTE + + +oil = IfcDistributionSystemEnum.OIL + + +operational = IfcDistributionSystemEnum.OPERATIONAL + + +operationaltelephonysystem = IfcDistributionSystemEnum.OPERATIONALTELEPHONYSYSTEM + + +overhead_contactline_system = IfcDistributionSystemEnum.OVERHEAD_CONTACTLINE_SYSTEM + + +powergeneration = IfcDistributionSystemEnum.POWERGENERATION + + +rainwater = IfcDistributionSystemEnum.RAINWATER + + +refrigeration = IfcDistributionSystemEnum.REFRIGERATION + + +return_circuit = IfcDistributionSystemEnum.RETURN_CIRCUIT + + +security = IfcDistributionSystemEnum.SECURITY + + +sewage = IfcDistributionSystemEnum.SEWAGE + + +signal = IfcDistributionSystemEnum.SIGNAL + + +stormwater = IfcDistributionSystemEnum.STORMWATER + + +telephone = IfcDistributionSystemEnum.TELEPHONE + + +tv = IfcDistributionSystemEnum.TV + + +vacuum = IfcDistributionSystemEnum.VACUUM + + +vent = IfcDistributionSystemEnum.VENT + + +ventilation = IfcDistributionSystemEnum.VENTILATION + + +wastewater = IfcDistributionSystemEnum.WASTEWATER + + +watersupply = IfcDistributionSystemEnum.WATERSUPPLY + + +userdefined = IfcDistributionSystemEnum.USERDEFINED + + +notdefined = IfcDistributionSystemEnum.NOTDEFINED + + +IfcDocumentConfidentialityEnum = enum_namespace() + + +confidential = IfcDocumentConfidentialityEnum.CONFIDENTIAL + + +personal = IfcDocumentConfidentialityEnum.PERSONAL + + +public = IfcDocumentConfidentialityEnum.PUBLIC + + +restricted = IfcDocumentConfidentialityEnum.RESTRICTED + + +userdefined = IfcDocumentConfidentialityEnum.USERDEFINED + + +notdefined = IfcDocumentConfidentialityEnum.NOTDEFINED + + +IfcDocumentStatusEnum = enum_namespace() + + +draft = IfcDocumentStatusEnum.DRAFT + + +final = IfcDocumentStatusEnum.FINAL + + +finaldraft = IfcDocumentStatusEnum.FINALDRAFT + + +revision = IfcDocumentStatusEnum.REVISION + + +notdefined = IfcDocumentStatusEnum.NOTDEFINED + + +IfcDoorPanelOperationEnum = enum_namespace() + + +double_acting = IfcDoorPanelOperationEnum.DOUBLE_ACTING + + +fixedpanel = IfcDoorPanelOperationEnum.FIXEDPANEL + + +folding = IfcDoorPanelOperationEnum.FOLDING + + +revolving = IfcDoorPanelOperationEnum.REVOLVING + + +rollingup = IfcDoorPanelOperationEnum.ROLLINGUP + + +sliding = IfcDoorPanelOperationEnum.SLIDING + + +swinging = IfcDoorPanelOperationEnum.SWINGING + + +userdefined = IfcDoorPanelOperationEnum.USERDEFINED + + +notdefined = IfcDoorPanelOperationEnum.NOTDEFINED + + +IfcDoorPanelPositionEnum = enum_namespace() + + +left = IfcDoorPanelPositionEnum.LEFT + + +middle = IfcDoorPanelPositionEnum.MIDDLE + + +right = IfcDoorPanelPositionEnum.RIGHT + + +notdefined = IfcDoorPanelPositionEnum.NOTDEFINED + + +IfcDoorStyleConstructionEnum = enum_namespace() + + +aluminium = IfcDoorStyleConstructionEnum.ALUMINIUM + + +aluminium_plastic = IfcDoorStyleConstructionEnum.ALUMINIUM_PLASTIC + + +aluminium_wood = IfcDoorStyleConstructionEnum.ALUMINIUM_WOOD + + +high_grade_steel = IfcDoorStyleConstructionEnum.HIGH_GRADE_STEEL + + +plastic = IfcDoorStyleConstructionEnum.PLASTIC + + +steel = IfcDoorStyleConstructionEnum.STEEL + + +wood = IfcDoorStyleConstructionEnum.WOOD + + +userdefined = IfcDoorStyleConstructionEnum.USERDEFINED + + +notdefined = IfcDoorStyleConstructionEnum.NOTDEFINED + + +IfcDoorStyleOperationEnum = enum_namespace() + + +double_door_double_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +double_door_folding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_FOLDING + + +double_door_single_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_door_sliding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SLIDING + + +double_swing_left = IfcDoorStyleOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorStyleOperationEnum.DOUBLE_SWING_RIGHT + + +folding_to_left = IfcDoorStyleOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorStyleOperationEnum.FOLDING_TO_RIGHT + + +revolving = IfcDoorStyleOperationEnum.REVOLVING + + +rollingup = IfcDoorStyleOperationEnum.ROLLINGUP + + +single_swing_left = IfcDoorStyleOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorStyleOperationEnum.SINGLE_SWING_RIGHT + + +sliding_to_left = IfcDoorStyleOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorStyleOperationEnum.SLIDING_TO_RIGHT + + +userdefined = IfcDoorStyleOperationEnum.USERDEFINED + + +notdefined = IfcDoorStyleOperationEnum.NOTDEFINED + + +IfcDoorTypeEnum = enum_namespace() + + +boom_barrier = IfcDoorTypeEnum.BOOM_BARRIER + + +door = IfcDoorTypeEnum.DOOR + + +gate = IfcDoorTypeEnum.GATE + + +trapdoor = IfcDoorTypeEnum.TRAPDOOR + + +turnstile = IfcDoorTypeEnum.TURNSTILE + + +userdefined = IfcDoorTypeEnum.USERDEFINED + + +notdefined = IfcDoorTypeEnum.NOTDEFINED + + +IfcDoorTypeOperationEnum = enum_namespace() + + +double_panel_double_swing = IfcDoorTypeOperationEnum.DOUBLE_PANEL_DOUBLE_SWING + + +double_panel_folding = IfcDoorTypeOperationEnum.DOUBLE_PANEL_FOLDING + + +double_panel_lifting_vertical = IfcDoorTypeOperationEnum.DOUBLE_PANEL_LIFTING_VERTICAL + + +double_panel_single_swing = IfcDoorTypeOperationEnum.DOUBLE_PANEL_SINGLE_SWING + + +double_panel_single_swing_opposite_left = IfcDoorTypeOperationEnum.DOUBLE_PANEL_SINGLE_SWING_OPPOSITE_LEFT + + +double_panel_single_swing_opposite_right = IfcDoorTypeOperationEnum.DOUBLE_PANEL_SINGLE_SWING_OPPOSITE_RIGHT + + +double_panel_sliding = IfcDoorTypeOperationEnum.DOUBLE_PANEL_SLIDING + + +double_swing_left = IfcDoorTypeOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorTypeOperationEnum.DOUBLE_SWING_RIGHT + + +folding_to_left = IfcDoorTypeOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorTypeOperationEnum.FOLDING_TO_RIGHT + + +lifting_horizontal = IfcDoorTypeOperationEnum.LIFTING_HORIZONTAL + + +lifting_vertical_left = IfcDoorTypeOperationEnum.LIFTING_VERTICAL_LEFT + + +lifting_vertical_right = IfcDoorTypeOperationEnum.LIFTING_VERTICAL_RIGHT + + +revolving_horizontal = IfcDoorTypeOperationEnum.REVOLVING_HORIZONTAL + + +revolving_vertical = IfcDoorTypeOperationEnum.REVOLVING_VERTICAL + + +rollingup = IfcDoorTypeOperationEnum.ROLLINGUP + + +single_swing_left = IfcDoorTypeOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorTypeOperationEnum.SINGLE_SWING_RIGHT + + +sliding_to_left = IfcDoorTypeOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorTypeOperationEnum.SLIDING_TO_RIGHT + + +swing_fixed_left = IfcDoorTypeOperationEnum.SWING_FIXED_LEFT + + +swing_fixed_right = IfcDoorTypeOperationEnum.SWING_FIXED_RIGHT + + +userdefined = IfcDoorTypeOperationEnum.USERDEFINED + + +notdefined = IfcDoorTypeOperationEnum.NOTDEFINED + + +IfcDuctFittingTypeEnum = enum_namespace() + + +bend = IfcDuctFittingTypeEnum.BEND + + +connector = IfcDuctFittingTypeEnum.CONNECTOR + + +entry = IfcDuctFittingTypeEnum.ENTRY + + +exit = IfcDuctFittingTypeEnum.EXIT + + +junction = IfcDuctFittingTypeEnum.JUNCTION + + +obstruction = IfcDuctFittingTypeEnum.OBSTRUCTION + + +transition = IfcDuctFittingTypeEnum.TRANSITION + + +userdefined = IfcDuctFittingTypeEnum.USERDEFINED + + +notdefined = IfcDuctFittingTypeEnum.NOTDEFINED + + +IfcDuctSegmentTypeEnum = enum_namespace() + + +flexiblesegment = IfcDuctSegmentTypeEnum.FLEXIBLESEGMENT + + +rigidsegment = IfcDuctSegmentTypeEnum.RIGIDSEGMENT + + +userdefined = IfcDuctSegmentTypeEnum.USERDEFINED + + +notdefined = IfcDuctSegmentTypeEnum.NOTDEFINED + + +IfcDuctSilencerTypeEnum = enum_namespace() + + +flatoval = IfcDuctSilencerTypeEnum.FLATOVAL + + +rectangular = IfcDuctSilencerTypeEnum.RECTANGULAR + + +round = IfcDuctSilencerTypeEnum.ROUND + + +userdefined = IfcDuctSilencerTypeEnum.USERDEFINED + + +notdefined = IfcDuctSilencerTypeEnum.NOTDEFINED + + +IfcEarthworksCutTypeEnum = enum_namespace() + + +base_excavation = IfcEarthworksCutTypeEnum.BASE_EXCAVATION + + +cut = IfcEarthworksCutTypeEnum.CUT + + +dredging = IfcEarthworksCutTypeEnum.DREDGING + + +excavation = IfcEarthworksCutTypeEnum.EXCAVATION + + +overexcavation = IfcEarthworksCutTypeEnum.OVEREXCAVATION + + +pavementmilling = IfcEarthworksCutTypeEnum.PAVEMENTMILLING + + +stepexcavation = IfcEarthworksCutTypeEnum.STEPEXCAVATION + + +topsoilremoval = IfcEarthworksCutTypeEnum.TOPSOILREMOVAL + + +trench = IfcEarthworksCutTypeEnum.TRENCH + + +userdefined = IfcEarthworksCutTypeEnum.USERDEFINED + + +notdefined = IfcEarthworksCutTypeEnum.NOTDEFINED + + +IfcEarthworksFillTypeEnum = enum_namespace() + + +backfill = IfcEarthworksFillTypeEnum.BACKFILL + + +counterweight = IfcEarthworksFillTypeEnum.COUNTERWEIGHT + + +embankment = IfcEarthworksFillTypeEnum.EMBANKMENT + + +slopefill = IfcEarthworksFillTypeEnum.SLOPEFILL + + +subgrade = IfcEarthworksFillTypeEnum.SUBGRADE + + +subgradebed = IfcEarthworksFillTypeEnum.SUBGRADEBED + + +transitionsection = IfcEarthworksFillTypeEnum.TRANSITIONSECTION + + +userdefined = IfcEarthworksFillTypeEnum.USERDEFINED + + +notdefined = IfcEarthworksFillTypeEnum.NOTDEFINED + + +IfcElectricApplianceTypeEnum = enum_namespace() + + +dishwasher = IfcElectricApplianceTypeEnum.DISHWASHER + + +electriccooker = IfcElectricApplianceTypeEnum.ELECTRICCOOKER + + +freestandingelectricheater = IfcElectricApplianceTypeEnum.FREESTANDINGELECTRICHEATER + + +freestandingfan = IfcElectricApplianceTypeEnum.FREESTANDINGFAN + + +freestandingwatercooler = IfcElectricApplianceTypeEnum.FREESTANDINGWATERCOOLER + + +freestandingwaterheater = IfcElectricApplianceTypeEnum.FREESTANDINGWATERHEATER + + +freezer = IfcElectricApplianceTypeEnum.FREEZER + + +fridge_freezer = IfcElectricApplianceTypeEnum.FRIDGE_FREEZER + + +handdryer = IfcElectricApplianceTypeEnum.HANDDRYER + + +kitchenmachine = IfcElectricApplianceTypeEnum.KITCHENMACHINE + + +microwave = IfcElectricApplianceTypeEnum.MICROWAVE + + +photocopier = IfcElectricApplianceTypeEnum.PHOTOCOPIER + + +refrigerator = IfcElectricApplianceTypeEnum.REFRIGERATOR + + +tumbledryer = IfcElectricApplianceTypeEnum.TUMBLEDRYER + + +vendingmachine = IfcElectricApplianceTypeEnum.VENDINGMACHINE + + +washingmachine = IfcElectricApplianceTypeEnum.WASHINGMACHINE + + +userdefined = IfcElectricApplianceTypeEnum.USERDEFINED + + +notdefined = IfcElectricApplianceTypeEnum.NOTDEFINED + + +IfcElectricDistributionBoardTypeEnum = enum_namespace() + + +consumerunit = IfcElectricDistributionBoardTypeEnum.CONSUMERUNIT + + +distributionboard = IfcElectricDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +motorcontrolcentre = IfcElectricDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +switchboard = IfcElectricDistributionBoardTypeEnum.SWITCHBOARD + + +userdefined = IfcElectricDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcElectricDistributionBoardTypeEnum.NOTDEFINED + + +IfcElectricFlowStorageDeviceTypeEnum = enum_namespace() + + +battery = IfcElectricFlowStorageDeviceTypeEnum.BATTERY + + +capacitor = IfcElectricFlowStorageDeviceTypeEnum.CAPACITOR + + +capacitorbank = IfcElectricFlowStorageDeviceTypeEnum.CAPACITORBANK + + +compensator = IfcElectricFlowStorageDeviceTypeEnum.COMPENSATOR + + +harmonicfilter = IfcElectricFlowStorageDeviceTypeEnum.HARMONICFILTER + + +inductor = IfcElectricFlowStorageDeviceTypeEnum.INDUCTOR + + +inductorbank = IfcElectricFlowStorageDeviceTypeEnum.INDUCTORBANK + + +recharger = IfcElectricFlowStorageDeviceTypeEnum.RECHARGER + + +ups = IfcElectricFlowStorageDeviceTypeEnum.UPS + + +userdefined = IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowStorageDeviceTypeEnum.NOTDEFINED + + +IfcElectricFlowTreatmentDeviceTypeEnum = enum_namespace() + + +electronicfilter = IfcElectricFlowTreatmentDeviceTypeEnum.ELECTRONICFILTER + + +userdefined = IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowTreatmentDeviceTypeEnum.NOTDEFINED + + +IfcElectricGeneratorTypeEnum = enum_namespace() + + +chp = IfcElectricGeneratorTypeEnum.CHP + + +enginegenerator = IfcElectricGeneratorTypeEnum.ENGINEGENERATOR + + +standalone = IfcElectricGeneratorTypeEnum.STANDALONE + + +userdefined = IfcElectricGeneratorTypeEnum.USERDEFINED + + +notdefined = IfcElectricGeneratorTypeEnum.NOTDEFINED + + +IfcElectricMotorTypeEnum = enum_namespace() + + +dc = IfcElectricMotorTypeEnum.DC + + +induction = IfcElectricMotorTypeEnum.INDUCTION + + +polyphase = IfcElectricMotorTypeEnum.POLYPHASE + + +reluctancesynchronous = IfcElectricMotorTypeEnum.RELUCTANCESYNCHRONOUS + + +synchronous = IfcElectricMotorTypeEnum.SYNCHRONOUS + + +userdefined = IfcElectricMotorTypeEnum.USERDEFINED + + +notdefined = IfcElectricMotorTypeEnum.NOTDEFINED + + +IfcElectricTimeControlTypeEnum = enum_namespace() + + +relay = IfcElectricTimeControlTypeEnum.RELAY + + +timeclock = IfcElectricTimeControlTypeEnum.TIMECLOCK + + +timedelay = IfcElectricTimeControlTypeEnum.TIMEDELAY + + +userdefined = IfcElectricTimeControlTypeEnum.USERDEFINED + + +notdefined = IfcElectricTimeControlTypeEnum.NOTDEFINED + + +IfcElementAssemblyTypeEnum = enum_namespace() + + +abutment = IfcElementAssemblyTypeEnum.ABUTMENT + + +accessory_assembly = IfcElementAssemblyTypeEnum.ACCESSORY_ASSEMBLY + + +arch = IfcElementAssemblyTypeEnum.ARCH + + +beam_grid = IfcElementAssemblyTypeEnum.BEAM_GRID + + +braced_frame = IfcElementAssemblyTypeEnum.BRACED_FRAME + + +cross_bracing = IfcElementAssemblyTypeEnum.CROSS_BRACING + + +deck = IfcElementAssemblyTypeEnum.DECK + + +dilatationpanel = IfcElementAssemblyTypeEnum.DILATATIONPANEL + + +entranceworks = IfcElementAssemblyTypeEnum.ENTRANCEWORKS + + +girder = IfcElementAssemblyTypeEnum.GIRDER + + +grid = IfcElementAssemblyTypeEnum.GRID + + +mast = IfcElementAssemblyTypeEnum.MAST + + +pier = IfcElementAssemblyTypeEnum.PIER + + +pylon = IfcElementAssemblyTypeEnum.PYLON + + +rail_mechanical_equipment_assembly = IfcElementAssemblyTypeEnum.RAIL_MECHANICAL_EQUIPMENT_ASSEMBLY + + +reinforcement_unit = IfcElementAssemblyTypeEnum.REINFORCEMENT_UNIT + + +rigid_frame = IfcElementAssemblyTypeEnum.RIGID_FRAME + + +shelter = IfcElementAssemblyTypeEnum.SHELTER + + +signalassembly = IfcElementAssemblyTypeEnum.SIGNALASSEMBLY + + +slab_field = IfcElementAssemblyTypeEnum.SLAB_FIELD + + +sumpbuster = IfcElementAssemblyTypeEnum.SUMPBUSTER + + +supportingassembly = IfcElementAssemblyTypeEnum.SUPPORTINGASSEMBLY + + +suspensionassembly = IfcElementAssemblyTypeEnum.SUSPENSIONASSEMBLY + + +trackpanel = IfcElementAssemblyTypeEnum.TRACKPANEL + + +traction_switching_assembly = IfcElementAssemblyTypeEnum.TRACTION_SWITCHING_ASSEMBLY + + +traffic_calming_device = IfcElementAssemblyTypeEnum.TRAFFIC_CALMING_DEVICE + + +truss = IfcElementAssemblyTypeEnum.TRUSS + + +turnoutpanel = IfcElementAssemblyTypeEnum.TURNOUTPANEL + + +userdefined = IfcElementAssemblyTypeEnum.USERDEFINED + + +notdefined = IfcElementAssemblyTypeEnum.NOTDEFINED + + +IfcElementCompositionEnum = enum_namespace() + + +complex = IfcElementCompositionEnum.COMPLEX + + +element = IfcElementCompositionEnum.ELEMENT + + +partial = IfcElementCompositionEnum.PARTIAL + + +IfcEngineTypeEnum = enum_namespace() + + +externalcombustion = IfcEngineTypeEnum.EXTERNALCOMBUSTION + + +internalcombustion = IfcEngineTypeEnum.INTERNALCOMBUSTION + + +userdefined = IfcEngineTypeEnum.USERDEFINED + + +notdefined = IfcEngineTypeEnum.NOTDEFINED + + +IfcEvaporativeCoolerTypeEnum = enum_namespace() + + +directevaporativeairwasher = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEAIRWASHER + + +directevaporativepackagedrotaryaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER + + +directevaporativerandommediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER + + +directevaporativerigidmediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER + + +directevaporativeslingerspackagedaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER + + +indirectdirectcombination = IfcEvaporativeCoolerTypeEnum.INDIRECTDIRECTCOMBINATION + + +indirectevaporativecoolingtowerorcoilcooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER + + +indirectevaporativepackageaircooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEPACKAGEAIRCOOLER + + +indirectevaporativewetcoil = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEWETCOIL + + +userdefined = IfcEvaporativeCoolerTypeEnum.USERDEFINED + + +notdefined = IfcEvaporativeCoolerTypeEnum.NOTDEFINED + + +IfcEvaporatorTypeEnum = enum_namespace() + + +directexpansion = IfcEvaporatorTypeEnum.DIRECTEXPANSION + + +directexpansionbrazedplate = IfcEvaporatorTypeEnum.DIRECTEXPANSIONBRAZEDPLATE + + +directexpansionshellandtube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONSHELLANDTUBE + + +directexpansiontubeintube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONTUBEINTUBE + + +floodedshellandtube = IfcEvaporatorTypeEnum.FLOODEDSHELLANDTUBE + + +shellandcoil = IfcEvaporatorTypeEnum.SHELLANDCOIL + + +userdefined = IfcEvaporatorTypeEnum.USERDEFINED + + +notdefined = IfcEvaporatorTypeEnum.NOTDEFINED + + +IfcEventTriggerTypeEnum = enum_namespace() + + +eventcomplex = IfcEventTriggerTypeEnum.EVENTCOMPLEX + + +eventmessage = IfcEventTriggerTypeEnum.EVENTMESSAGE + + +eventrule = IfcEventTriggerTypeEnum.EVENTRULE + + +eventtime = IfcEventTriggerTypeEnum.EVENTTIME + + +userdefined = IfcEventTriggerTypeEnum.USERDEFINED + + +notdefined = IfcEventTriggerTypeEnum.NOTDEFINED + + +IfcEventTypeEnum = enum_namespace() + + +endevent = IfcEventTypeEnum.ENDEVENT + + +intermediateevent = IfcEventTypeEnum.INTERMEDIATEEVENT + + +startevent = IfcEventTypeEnum.STARTEVENT + + +userdefined = IfcEventTypeEnum.USERDEFINED + + +notdefined = IfcEventTypeEnum.NOTDEFINED + + +IfcExternalSpatialElementTypeEnum = enum_namespace() + + +external = IfcExternalSpatialElementTypeEnum.EXTERNAL + + +external_earth = IfcExternalSpatialElementTypeEnum.EXTERNAL_EARTH + + +external_fire = IfcExternalSpatialElementTypeEnum.EXTERNAL_FIRE + + +external_water = IfcExternalSpatialElementTypeEnum.EXTERNAL_WATER + + +userdefined = IfcExternalSpatialElementTypeEnum.USERDEFINED + + +notdefined = IfcExternalSpatialElementTypeEnum.NOTDEFINED + + +IfcFacilityPartCommonTypeEnum = enum_namespace() + + +aboveground = IfcFacilityPartCommonTypeEnum.ABOVEGROUND + + +belowground = IfcFacilityPartCommonTypeEnum.BELOWGROUND + + +junction = IfcFacilityPartCommonTypeEnum.JUNCTION + + +levelcrossing = IfcFacilityPartCommonTypeEnum.LEVELCROSSING + + +segment = IfcFacilityPartCommonTypeEnum.SEGMENT + + +substructure = IfcFacilityPartCommonTypeEnum.SUBSTRUCTURE + + +superstructure = IfcFacilityPartCommonTypeEnum.SUPERSTRUCTURE + + +terminal = IfcFacilityPartCommonTypeEnum.TERMINAL + + +userdefined = IfcFacilityPartCommonTypeEnum.USERDEFINED + + +notdefined = IfcFacilityPartCommonTypeEnum.NOTDEFINED + + +IfcFacilityUsageEnum = enum_namespace() + + +lateral = IfcFacilityUsageEnum.LATERAL + + +longitudinal = IfcFacilityUsageEnum.LONGITUDINAL + + +region = IfcFacilityUsageEnum.REGION + + +vertical = IfcFacilityUsageEnum.VERTICAL + + +userdefined = IfcFacilityUsageEnum.USERDEFINED + + +notdefined = IfcFacilityUsageEnum.NOTDEFINED + + +IfcFanTypeEnum = enum_namespace() + + +centrifugalairfoil = IfcFanTypeEnum.CENTRIFUGALAIRFOIL + + +centrifugalbackwardinclinedcurved = IfcFanTypeEnum.CENTRIFUGALBACKWARDINCLINEDCURVED + + +centrifugalforwardcurved = IfcFanTypeEnum.CENTRIFUGALFORWARDCURVED + + +centrifugalradial = IfcFanTypeEnum.CENTRIFUGALRADIAL + + +propelloraxial = IfcFanTypeEnum.PROPELLORAXIAL + + +tubeaxial = IfcFanTypeEnum.TUBEAXIAL + + +vaneaxial = IfcFanTypeEnum.VANEAXIAL + + +userdefined = IfcFanTypeEnum.USERDEFINED + + +notdefined = IfcFanTypeEnum.NOTDEFINED + + +IfcFastenerTypeEnum = enum_namespace() + + +glue = IfcFastenerTypeEnum.GLUE + + +mortar = IfcFastenerTypeEnum.MORTAR + + +weld = IfcFastenerTypeEnum.WELD + + +userdefined = IfcFastenerTypeEnum.USERDEFINED + + +notdefined = IfcFastenerTypeEnum.NOTDEFINED + + +IfcFilterTypeEnum = enum_namespace() + + +airparticlefilter = IfcFilterTypeEnum.AIRPARTICLEFILTER + + +compressedairfilter = IfcFilterTypeEnum.COMPRESSEDAIRFILTER + + +odorfilter = IfcFilterTypeEnum.ODORFILTER + + +oilfilter = IfcFilterTypeEnum.OILFILTER + + +strainer = IfcFilterTypeEnum.STRAINER + + +waterfilter = IfcFilterTypeEnum.WATERFILTER + + +userdefined = IfcFilterTypeEnum.USERDEFINED + + +notdefined = IfcFilterTypeEnum.NOTDEFINED + + +IfcFireSuppressionTerminalTypeEnum = enum_namespace() + + +breechinginlet = IfcFireSuppressionTerminalTypeEnum.BREECHINGINLET + + +firehydrant = IfcFireSuppressionTerminalTypeEnum.FIREHYDRANT + + +firemonitor = IfcFireSuppressionTerminalTypeEnum.FIREMONITOR + + +hosereel = IfcFireSuppressionTerminalTypeEnum.HOSEREEL + + +sprinkler = IfcFireSuppressionTerminalTypeEnum.SPRINKLER + + +sprinklerdeflector = IfcFireSuppressionTerminalTypeEnum.SPRINKLERDEFLECTOR + + +userdefined = IfcFireSuppressionTerminalTypeEnum.USERDEFINED + + +notdefined = IfcFireSuppressionTerminalTypeEnum.NOTDEFINED + + +IfcFlowDirectionEnum = enum_namespace() + + +sink = IfcFlowDirectionEnum.SINK + + +source = IfcFlowDirectionEnum.SOURCE + + +sourceandsink = IfcFlowDirectionEnum.SOURCEANDSINK + + +notdefined = IfcFlowDirectionEnum.NOTDEFINED + + +IfcFlowInstrumentTypeEnum = enum_namespace() + + +ammeter = IfcFlowInstrumentTypeEnum.AMMETER + + +combined = IfcFlowInstrumentTypeEnum.COMBINED + + +frequencymeter = IfcFlowInstrumentTypeEnum.FREQUENCYMETER + + +phaseanglemeter = IfcFlowInstrumentTypeEnum.PHASEANGLEMETER + + +powerfactormeter = IfcFlowInstrumentTypeEnum.POWERFACTORMETER + + +pressuregauge = IfcFlowInstrumentTypeEnum.PRESSUREGAUGE + + +thermometer = IfcFlowInstrumentTypeEnum.THERMOMETER + + +voltmeter = IfcFlowInstrumentTypeEnum.VOLTMETER + + +voltmeter_peak = IfcFlowInstrumentTypeEnum.VOLTMETER_PEAK + + +voltmeter_rms = IfcFlowInstrumentTypeEnum.VOLTMETER_RMS + + +userdefined = IfcFlowInstrumentTypeEnum.USERDEFINED + + +notdefined = IfcFlowInstrumentTypeEnum.NOTDEFINED + + +IfcFlowMeterTypeEnum = enum_namespace() + + +energymeter = IfcFlowMeterTypeEnum.ENERGYMETER + + +gasmeter = IfcFlowMeterTypeEnum.GASMETER + + +oilmeter = IfcFlowMeterTypeEnum.OILMETER + + +watermeter = IfcFlowMeterTypeEnum.WATERMETER + + +userdefined = IfcFlowMeterTypeEnum.USERDEFINED + + +notdefined = IfcFlowMeterTypeEnum.NOTDEFINED + + +IfcFootingTypeEnum = enum_namespace() + + +caisson_foundation = IfcFootingTypeEnum.CAISSON_FOUNDATION + + +footing_beam = IfcFootingTypeEnum.FOOTING_BEAM + + +pad_footing = IfcFootingTypeEnum.PAD_FOOTING + + +pile_cap = IfcFootingTypeEnum.PILE_CAP + + +strip_footing = IfcFootingTypeEnum.STRIP_FOOTING + + +userdefined = IfcFootingTypeEnum.USERDEFINED + + +notdefined = IfcFootingTypeEnum.NOTDEFINED + + +IfcFurnitureTypeEnum = enum_namespace() + + +bed = IfcFurnitureTypeEnum.BED + + +chair = IfcFurnitureTypeEnum.CHAIR + + +desk = IfcFurnitureTypeEnum.DESK + + +filecabinet = IfcFurnitureTypeEnum.FILECABINET + + +shelf = IfcFurnitureTypeEnum.SHELF + + +sofa = IfcFurnitureTypeEnum.SOFA + + +table = IfcFurnitureTypeEnum.TABLE + + +technicalcabinet = IfcFurnitureTypeEnum.TECHNICALCABINET + + +userdefined = IfcFurnitureTypeEnum.USERDEFINED + + +notdefined = IfcFurnitureTypeEnum.NOTDEFINED + + +IfcGeographicElementTypeEnum = enum_namespace() + + +soil_boring_point = IfcGeographicElementTypeEnum.SOIL_BORING_POINT + + +terrain = IfcGeographicElementTypeEnum.TERRAIN + + +vegetation = IfcGeographicElementTypeEnum.VEGETATION + + +userdefined = IfcGeographicElementTypeEnum.USERDEFINED + + +notdefined = IfcGeographicElementTypeEnum.NOTDEFINED + + +IfcGeometricProjectionEnum = enum_namespace() + + +elevation_view = IfcGeometricProjectionEnum.ELEVATION_VIEW + + +graph_view = IfcGeometricProjectionEnum.GRAPH_VIEW + + +model_view = IfcGeometricProjectionEnum.MODEL_VIEW + + +plan_view = IfcGeometricProjectionEnum.PLAN_VIEW + + +reflected_plan_view = IfcGeometricProjectionEnum.REFLECTED_PLAN_VIEW + + +section_view = IfcGeometricProjectionEnum.SECTION_VIEW + + +sketch_view = IfcGeometricProjectionEnum.SKETCH_VIEW + + +userdefined = IfcGeometricProjectionEnum.USERDEFINED + + +notdefined = IfcGeometricProjectionEnum.NOTDEFINED + + +IfcGeotechnicalStratumTypeEnum = enum_namespace() + + +solid = IfcGeotechnicalStratumTypeEnum.SOLID + + +void = IfcGeotechnicalStratumTypeEnum.VOID + + +water = IfcGeotechnicalStratumTypeEnum.WATER + + +userdefined = IfcGeotechnicalStratumTypeEnum.USERDEFINED + + +notdefined = IfcGeotechnicalStratumTypeEnum.NOTDEFINED + + +IfcGlobalOrLocalEnum = enum_namespace() + + +global_coords = IfcGlobalOrLocalEnum.GLOBAL_COORDS + + +local_coords = IfcGlobalOrLocalEnum.LOCAL_COORDS + + +IfcGridTypeEnum = enum_namespace() + + +irregular = IfcGridTypeEnum.IRREGULAR + + +radial = IfcGridTypeEnum.RADIAL + + +rectangular = IfcGridTypeEnum.RECTANGULAR + + +triangular = IfcGridTypeEnum.TRIANGULAR + + +userdefined = IfcGridTypeEnum.USERDEFINED + + +notdefined = IfcGridTypeEnum.NOTDEFINED + + +IfcHeatExchangerTypeEnum = enum_namespace() + + +plate = IfcHeatExchangerTypeEnum.PLATE + + +shellandtube = IfcHeatExchangerTypeEnum.SHELLANDTUBE + + +turnoutheating = IfcHeatExchangerTypeEnum.TURNOUTHEATING + + +userdefined = IfcHeatExchangerTypeEnum.USERDEFINED + + +notdefined = IfcHeatExchangerTypeEnum.NOTDEFINED + + +IfcHumidifierTypeEnum = enum_namespace() + + +adiabaticairwasher = IfcHumidifierTypeEnum.ADIABATICAIRWASHER + + +adiabaticatomizing = IfcHumidifierTypeEnum.ADIABATICATOMIZING + + +adiabaticcompressedairnozzle = IfcHumidifierTypeEnum.ADIABATICCOMPRESSEDAIRNOZZLE + + +adiabaticpan = IfcHumidifierTypeEnum.ADIABATICPAN + + +adiabaticrigidmedia = IfcHumidifierTypeEnum.ADIABATICRIGIDMEDIA + + +adiabaticultrasonic = IfcHumidifierTypeEnum.ADIABATICULTRASONIC + + +adiabaticwettedelement = IfcHumidifierTypeEnum.ADIABATICWETTEDELEMENT + + +assistedbutane = IfcHumidifierTypeEnum.ASSISTEDBUTANE + + +assistedelectric = IfcHumidifierTypeEnum.ASSISTEDELECTRIC + + +assistednaturalgas = IfcHumidifierTypeEnum.ASSISTEDNATURALGAS + + +assistedpropane = IfcHumidifierTypeEnum.ASSISTEDPROPANE + + +assistedsteam = IfcHumidifierTypeEnum.ASSISTEDSTEAM + + +steaminjection = IfcHumidifierTypeEnum.STEAMINJECTION + + +userdefined = IfcHumidifierTypeEnum.USERDEFINED + + +notdefined = IfcHumidifierTypeEnum.NOTDEFINED + + +IfcImpactProtectionDeviceTypeEnum = enum_namespace() + + +bumper = IfcImpactProtectionDeviceTypeEnum.BUMPER + + +crashcushion = IfcImpactProtectionDeviceTypeEnum.CRASHCUSHION + + +dampingsystem = IfcImpactProtectionDeviceTypeEnum.DAMPINGSYSTEM + + +fender = IfcImpactProtectionDeviceTypeEnum.FENDER + + +userdefined = IfcImpactProtectionDeviceTypeEnum.USERDEFINED + + +notdefined = IfcImpactProtectionDeviceTypeEnum.NOTDEFINED + + +IfcInterceptorTypeEnum = enum_namespace() + + +cyclonic = IfcInterceptorTypeEnum.CYCLONIC + + +grease = IfcInterceptorTypeEnum.GREASE + + +oil = IfcInterceptorTypeEnum.OIL + + +petrol = IfcInterceptorTypeEnum.PETROL + + +userdefined = IfcInterceptorTypeEnum.USERDEFINED + + +notdefined = IfcInterceptorTypeEnum.NOTDEFINED + + +IfcInternalOrExternalEnum = enum_namespace() + + +external = IfcInternalOrExternalEnum.EXTERNAL + + +external_earth = IfcInternalOrExternalEnum.EXTERNAL_EARTH + + +external_fire = IfcInternalOrExternalEnum.EXTERNAL_FIRE + + +external_water = IfcInternalOrExternalEnum.EXTERNAL_WATER + + +internal = IfcInternalOrExternalEnum.INTERNAL + + +notdefined = IfcInternalOrExternalEnum.NOTDEFINED + + +IfcInventoryTypeEnum = enum_namespace() + + +assetinventory = IfcInventoryTypeEnum.ASSETINVENTORY + + +furnitureinventory = IfcInventoryTypeEnum.FURNITUREINVENTORY + + +spaceinventory = IfcInventoryTypeEnum.SPACEINVENTORY + + +userdefined = IfcInventoryTypeEnum.USERDEFINED + + +notdefined = IfcInventoryTypeEnum.NOTDEFINED + + +IfcJunctionBoxTypeEnum = enum_namespace() + + +data = IfcJunctionBoxTypeEnum.DATA + + +power = IfcJunctionBoxTypeEnum.POWER + + +userdefined = IfcJunctionBoxTypeEnum.USERDEFINED + + +notdefined = IfcJunctionBoxTypeEnum.NOTDEFINED + + +IfcKnotType = enum_namespace() + + +piecewise_bezier_knots = IfcKnotType.PIECEWISE_BEZIER_KNOTS + + +quasi_uniform_knots = IfcKnotType.QUASI_UNIFORM_KNOTS + + +uniform_knots = IfcKnotType.UNIFORM_KNOTS + + +unspecified = IfcKnotType.UNSPECIFIED + + +IfcLaborResourceTypeEnum = enum_namespace() + + +administration = IfcLaborResourceTypeEnum.ADMINISTRATION + + +carpentry = IfcLaborResourceTypeEnum.CARPENTRY + + +cleaning = IfcLaborResourceTypeEnum.CLEANING + + +concrete = IfcLaborResourceTypeEnum.CONCRETE + + +drywall = IfcLaborResourceTypeEnum.DRYWALL + + +electric = IfcLaborResourceTypeEnum.ELECTRIC + + +finishing = IfcLaborResourceTypeEnum.FINISHING + + +flooring = IfcLaborResourceTypeEnum.FLOORING + + +general = IfcLaborResourceTypeEnum.GENERAL + + +hvac = IfcLaborResourceTypeEnum.HVAC + + +landscaping = IfcLaborResourceTypeEnum.LANDSCAPING + + +masonry = IfcLaborResourceTypeEnum.MASONRY + + +painting = IfcLaborResourceTypeEnum.PAINTING + + +paving = IfcLaborResourceTypeEnum.PAVING + + +plumbing = IfcLaborResourceTypeEnum.PLUMBING + + +roofing = IfcLaborResourceTypeEnum.ROOFING + + +sitegrading = IfcLaborResourceTypeEnum.SITEGRADING + + +steelwork = IfcLaborResourceTypeEnum.STEELWORK + + +surveying = IfcLaborResourceTypeEnum.SURVEYING + + +userdefined = IfcLaborResourceTypeEnum.USERDEFINED + + +notdefined = IfcLaborResourceTypeEnum.NOTDEFINED + + +IfcLampTypeEnum = enum_namespace() + + +compactfluorescent = IfcLampTypeEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLampTypeEnum.FLUORESCENT + + +halogen = IfcLampTypeEnum.HALOGEN + + +highpressuremercury = IfcLampTypeEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLampTypeEnum.HIGHPRESSURESODIUM + + +led = IfcLampTypeEnum.LED + + +metalhalide = IfcLampTypeEnum.METALHALIDE + + +oled = IfcLampTypeEnum.OLED + + +tungstenfilament = IfcLampTypeEnum.TUNGSTENFILAMENT + + +userdefined = IfcLampTypeEnum.USERDEFINED + + +notdefined = IfcLampTypeEnum.NOTDEFINED + + +IfcLayerSetDirectionEnum = enum_namespace() + + +axis1 = IfcLayerSetDirectionEnum.AXIS1 + + +axis2 = IfcLayerSetDirectionEnum.AXIS2 + + +axis3 = IfcLayerSetDirectionEnum.AXIS3 + + +IfcLightDistributionCurveEnum = enum_namespace() + + +type_a = IfcLightDistributionCurveEnum.TYPE_A + + +type_b = IfcLightDistributionCurveEnum.TYPE_B + + +type_c = IfcLightDistributionCurveEnum.TYPE_C + + +notdefined = IfcLightDistributionCurveEnum.NOTDEFINED + + +IfcLightEmissionSourceEnum = enum_namespace() + + +compactfluorescent = IfcLightEmissionSourceEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLightEmissionSourceEnum.FLUORESCENT + + +highpressuremercury = IfcLightEmissionSourceEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLightEmissionSourceEnum.HIGHPRESSURESODIUM + + +lightemittingdiode = IfcLightEmissionSourceEnum.LIGHTEMITTINGDIODE + + +lowpressuresodium = IfcLightEmissionSourceEnum.LOWPRESSURESODIUM + + +lowvoltagehalogen = IfcLightEmissionSourceEnum.LOWVOLTAGEHALOGEN + + +mainvoltagehalogen = IfcLightEmissionSourceEnum.MAINVOLTAGEHALOGEN + + +metalhalide = IfcLightEmissionSourceEnum.METALHALIDE + + +tungstenfilament = IfcLightEmissionSourceEnum.TUNGSTENFILAMENT + + +notdefined = IfcLightEmissionSourceEnum.NOTDEFINED + + +IfcLightFixtureTypeEnum = enum_namespace() + + +directionsource = IfcLightFixtureTypeEnum.DIRECTIONSOURCE + + +pointsource = IfcLightFixtureTypeEnum.POINTSOURCE + + +securitylighting = IfcLightFixtureTypeEnum.SECURITYLIGHTING + + +userdefined = IfcLightFixtureTypeEnum.USERDEFINED + + +notdefined = IfcLightFixtureTypeEnum.NOTDEFINED + + +IfcLiquidTerminalTypeEnum = enum_namespace() + + +hosereel = IfcLiquidTerminalTypeEnum.HOSEREEL + + +loadingarm = IfcLiquidTerminalTypeEnum.LOADINGARM + + +userdefined = IfcLiquidTerminalTypeEnum.USERDEFINED + + +notdefined = IfcLiquidTerminalTypeEnum.NOTDEFINED + + +IfcLoadGroupTypeEnum = enum_namespace() + + +load_case = IfcLoadGroupTypeEnum.LOAD_CASE + + +load_combination = IfcLoadGroupTypeEnum.LOAD_COMBINATION + + +load_group = IfcLoadGroupTypeEnum.LOAD_GROUP + + +userdefined = IfcLoadGroupTypeEnum.USERDEFINED + + +notdefined = IfcLoadGroupTypeEnum.NOTDEFINED + + +IfcLogicalOperatorEnum = enum_namespace() + + +logicaland = IfcLogicalOperatorEnum.LOGICALAND + + +logicalnotand = IfcLogicalOperatorEnum.LOGICALNOTAND + + +logicalnotor = IfcLogicalOperatorEnum.LOGICALNOTOR + + +logicalor = IfcLogicalOperatorEnum.LOGICALOR + + +logicalxor = IfcLogicalOperatorEnum.LOGICALXOR + + +IfcMarineFacilityTypeEnum = enum_namespace() + + +barrierbeach = IfcMarineFacilityTypeEnum.BARRIERBEACH + + +breakwater = IfcMarineFacilityTypeEnum.BREAKWATER + + +canal = IfcMarineFacilityTypeEnum.CANAL + + +drydock = IfcMarineFacilityTypeEnum.DRYDOCK + + +floatingdock = IfcMarineFacilityTypeEnum.FLOATINGDOCK + + +hydrolift = IfcMarineFacilityTypeEnum.HYDROLIFT + + +jetty = IfcMarineFacilityTypeEnum.JETTY + + +launchrecovery = IfcMarineFacilityTypeEnum.LAUNCHRECOVERY + + +marinedefence = IfcMarineFacilityTypeEnum.MARINEDEFENCE + + +navigationalchannel = IfcMarineFacilityTypeEnum.NAVIGATIONALCHANNEL + + +port = IfcMarineFacilityTypeEnum.PORT + + +quay = IfcMarineFacilityTypeEnum.QUAY + + +revetment = IfcMarineFacilityTypeEnum.REVETMENT + + +shiplift = IfcMarineFacilityTypeEnum.SHIPLIFT + + +shiplock = IfcMarineFacilityTypeEnum.SHIPLOCK + + +shipyard = IfcMarineFacilityTypeEnum.SHIPYARD + + +slipway = IfcMarineFacilityTypeEnum.SLIPWAY + + +waterway = IfcMarineFacilityTypeEnum.WATERWAY + + +waterwayshiplift = IfcMarineFacilityTypeEnum.WATERWAYSHIPLIFT + + +userdefined = IfcMarineFacilityTypeEnum.USERDEFINED + + +notdefined = IfcMarineFacilityTypeEnum.NOTDEFINED + + +IfcMarinePartTypeEnum = enum_namespace() + + +abovewaterline = IfcMarinePartTypeEnum.ABOVEWATERLINE + + +anchorage = IfcMarinePartTypeEnum.ANCHORAGE + + +approachchannel = IfcMarinePartTypeEnum.APPROACHCHANNEL + + +belowwaterline = IfcMarinePartTypeEnum.BELOWWATERLINE + + +berthingstructure = IfcMarinePartTypeEnum.BERTHINGSTRUCTURE + + +chamber = IfcMarinePartTypeEnum.CHAMBER + + +cill_level = IfcMarinePartTypeEnum.CILL_LEVEL + + +copelevel = IfcMarinePartTypeEnum.COPELEVEL + + +core = IfcMarinePartTypeEnum.CORE + + +crest = IfcMarinePartTypeEnum.CREST + + +gatehead = IfcMarinePartTypeEnum.GATEHEAD + + +gudingstructure = IfcMarinePartTypeEnum.GUDINGSTRUCTURE + + +highwaterline = IfcMarinePartTypeEnum.HIGHWATERLINE + + +landfield = IfcMarinePartTypeEnum.LANDFIELD + + +leewardside = IfcMarinePartTypeEnum.LEEWARDSIDE + + +lowwaterline = IfcMarinePartTypeEnum.LOWWATERLINE + + +manufacturing = IfcMarinePartTypeEnum.MANUFACTURING + + +navigationalarea = IfcMarinePartTypeEnum.NAVIGATIONALAREA + + +protection = IfcMarinePartTypeEnum.PROTECTION + + +shiptransfer = IfcMarinePartTypeEnum.SHIPTRANSFER + + +storagearea = IfcMarinePartTypeEnum.STORAGEAREA + + +vehicleservicing = IfcMarinePartTypeEnum.VEHICLESERVICING + + +waterfield = IfcMarinePartTypeEnum.WATERFIELD + + +weatherside = IfcMarinePartTypeEnum.WEATHERSIDE + + +userdefined = IfcMarinePartTypeEnum.USERDEFINED + + +notdefined = IfcMarinePartTypeEnum.NOTDEFINED + + +IfcMechanicalFastenerTypeEnum = enum_namespace() + + +anchorbolt = IfcMechanicalFastenerTypeEnum.ANCHORBOLT + + +bolt = IfcMechanicalFastenerTypeEnum.BOLT + + +chain = IfcMechanicalFastenerTypeEnum.CHAIN + + +coupler = IfcMechanicalFastenerTypeEnum.COUPLER + + +dowel = IfcMechanicalFastenerTypeEnum.DOWEL + + +nail = IfcMechanicalFastenerTypeEnum.NAIL + + +nailplate = IfcMechanicalFastenerTypeEnum.NAILPLATE + + +railfastening = IfcMechanicalFastenerTypeEnum.RAILFASTENING + + +railjoint = IfcMechanicalFastenerTypeEnum.RAILJOINT + + +rivet = IfcMechanicalFastenerTypeEnum.RIVET + + +rope = IfcMechanicalFastenerTypeEnum.ROPE + + +screw = IfcMechanicalFastenerTypeEnum.SCREW + + +shearconnector = IfcMechanicalFastenerTypeEnum.SHEARCONNECTOR + + +staple = IfcMechanicalFastenerTypeEnum.STAPLE + + +studshearconnector = IfcMechanicalFastenerTypeEnum.STUDSHEARCONNECTOR + + +userdefined = IfcMechanicalFastenerTypeEnum.USERDEFINED + + +notdefined = IfcMechanicalFastenerTypeEnum.NOTDEFINED + + +IfcMedicalDeviceTypeEnum = enum_namespace() + + +airstation = IfcMedicalDeviceTypeEnum.AIRSTATION + + +feedairunit = IfcMedicalDeviceTypeEnum.FEEDAIRUNIT + + +oxygengenerator = IfcMedicalDeviceTypeEnum.OXYGENGENERATOR + + +oxygenplant = IfcMedicalDeviceTypeEnum.OXYGENPLANT + + +vacuumstation = IfcMedicalDeviceTypeEnum.VACUUMSTATION + + +userdefined = IfcMedicalDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMedicalDeviceTypeEnum.NOTDEFINED + + +IfcMemberTypeEnum = enum_namespace() + + +arch_segment = IfcMemberTypeEnum.ARCH_SEGMENT + + +brace = IfcMemberTypeEnum.BRACE + + +chord = IfcMemberTypeEnum.CHORD + + +collar = IfcMemberTypeEnum.COLLAR + + +member = IfcMemberTypeEnum.MEMBER + + +mullion = IfcMemberTypeEnum.MULLION + + +plate = IfcMemberTypeEnum.PLATE + + +post = IfcMemberTypeEnum.POST + + +purlin = IfcMemberTypeEnum.PURLIN + + +rafter = IfcMemberTypeEnum.RAFTER + + +stay_cable = IfcMemberTypeEnum.STAY_CABLE + + +stiffening_rib = IfcMemberTypeEnum.STIFFENING_RIB + + +stringer = IfcMemberTypeEnum.STRINGER + + +structuralcable = IfcMemberTypeEnum.STRUCTURALCABLE + + +strut = IfcMemberTypeEnum.STRUT + + +stud = IfcMemberTypeEnum.STUD + + +suspender = IfcMemberTypeEnum.SUSPENDER + + +suspension_cable = IfcMemberTypeEnum.SUSPENSION_CABLE + + +tiebar = IfcMemberTypeEnum.TIEBAR + + +userdefined = IfcMemberTypeEnum.USERDEFINED + + +notdefined = IfcMemberTypeEnum.NOTDEFINED + + +IfcMobileTelecommunicationsApplianceTypeEnum = enum_namespace() + + +accesspoint = IfcMobileTelecommunicationsApplianceTypeEnum.ACCESSPOINT + + +basebandunit = IfcMobileTelecommunicationsApplianceTypeEnum.BASEBANDUNIT + + +basetransceiverstation = IfcMobileTelecommunicationsApplianceTypeEnum.BASETRANSCEIVERSTATION + + +e_utran_node_b = IfcMobileTelecommunicationsApplianceTypeEnum.E_UTRAN_NODE_B + + +gateway_gprs_support_node = IfcMobileTelecommunicationsApplianceTypeEnum.GATEWAY_GPRS_SUPPORT_NODE + + +masterunit = IfcMobileTelecommunicationsApplianceTypeEnum.MASTERUNIT + + +mobileswitchingcenter = IfcMobileTelecommunicationsApplianceTypeEnum.MOBILESWITCHINGCENTER + + +mscserver = IfcMobileTelecommunicationsApplianceTypeEnum.MSCSERVER + + +packetcontrolunit = IfcMobileTelecommunicationsApplianceTypeEnum.PACKETCONTROLUNIT + + +remoteradiounit = IfcMobileTelecommunicationsApplianceTypeEnum.REMOTERADIOUNIT + + +remoteunit = IfcMobileTelecommunicationsApplianceTypeEnum.REMOTEUNIT + + +service_gprs_support_node = IfcMobileTelecommunicationsApplianceTypeEnum.SERVICE_GPRS_SUPPORT_NODE + + +subscriberserver = IfcMobileTelecommunicationsApplianceTypeEnum.SUBSCRIBERSERVER + + +userdefined = IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcMobileTelecommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcMooringDeviceTypeEnum = enum_namespace() + + +bollard = IfcMooringDeviceTypeEnum.BOLLARD + + +linetensioner = IfcMooringDeviceTypeEnum.LINETENSIONER + + +magneticdevice = IfcMooringDeviceTypeEnum.MAGNETICDEVICE + + +mooringhooks = IfcMooringDeviceTypeEnum.MOORINGHOOKS + + +vacuumdevice = IfcMooringDeviceTypeEnum.VACUUMDEVICE + + +userdefined = IfcMooringDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMooringDeviceTypeEnum.NOTDEFINED + + +IfcMotorConnectionTypeEnum = enum_namespace() + + +beltdrive = IfcMotorConnectionTypeEnum.BELTDRIVE + + +coupling = IfcMotorConnectionTypeEnum.COUPLING + + +directdrive = IfcMotorConnectionTypeEnum.DIRECTDRIVE + + +userdefined = IfcMotorConnectionTypeEnum.USERDEFINED + + +notdefined = IfcMotorConnectionTypeEnum.NOTDEFINED + + +IfcNavigationElementTypeEnum = enum_namespace() + + +beacon = IfcNavigationElementTypeEnum.BEACON + + +buoy = IfcNavigationElementTypeEnum.BUOY + + +userdefined = IfcNavigationElementTypeEnum.USERDEFINED + + +notdefined = IfcNavigationElementTypeEnum.NOTDEFINED + + +IfcObjectTypeEnum = enum_namespace() + + +actor = IfcObjectTypeEnum.ACTOR + + +control = IfcObjectTypeEnum.CONTROL + + +group = IfcObjectTypeEnum.GROUP + + +process = IfcObjectTypeEnum.PROCESS + + +product = IfcObjectTypeEnum.PRODUCT + + +project = IfcObjectTypeEnum.PROJECT + + +resource = IfcObjectTypeEnum.RESOURCE + + +notdefined = IfcObjectTypeEnum.NOTDEFINED + + +IfcObjectiveEnum = enum_namespace() + + +codecompliance = IfcObjectiveEnum.CODECOMPLIANCE + + +codewaiver = IfcObjectiveEnum.CODEWAIVER + + +designintent = IfcObjectiveEnum.DESIGNINTENT + + +external = IfcObjectiveEnum.EXTERNAL + + +healthandsafety = IfcObjectiveEnum.HEALTHANDSAFETY + + +mergeconflict = IfcObjectiveEnum.MERGECONFLICT + + +modelview = IfcObjectiveEnum.MODELVIEW + + +parameter = IfcObjectiveEnum.PARAMETER + + +requirement = IfcObjectiveEnum.REQUIREMENT + + +specification = IfcObjectiveEnum.SPECIFICATION + + +triggercondition = IfcObjectiveEnum.TRIGGERCONDITION + + +userdefined = IfcObjectiveEnum.USERDEFINED + + +notdefined = IfcObjectiveEnum.NOTDEFINED + + +IfcOccupantTypeEnum = enum_namespace() + + +assignee = IfcOccupantTypeEnum.ASSIGNEE + + +assignor = IfcOccupantTypeEnum.ASSIGNOR + + +lessee = IfcOccupantTypeEnum.LESSEE + + +lessor = IfcOccupantTypeEnum.LESSOR + + +lettingagent = IfcOccupantTypeEnum.LETTINGAGENT + + +owner = IfcOccupantTypeEnum.OWNER + + +tenant = IfcOccupantTypeEnum.TENANT + + +userdefined = IfcOccupantTypeEnum.USERDEFINED + + +notdefined = IfcOccupantTypeEnum.NOTDEFINED + + +IfcOpeningElementTypeEnum = enum_namespace() + + +opening = IfcOpeningElementTypeEnum.OPENING + + +recess = IfcOpeningElementTypeEnum.RECESS + + +userdefined = IfcOpeningElementTypeEnum.USERDEFINED + + +notdefined = IfcOpeningElementTypeEnum.NOTDEFINED + + +IfcOutletTypeEnum = enum_namespace() + + +audiovisualoutlet = IfcOutletTypeEnum.AUDIOVISUALOUTLET + + +communicationsoutlet = IfcOutletTypeEnum.COMMUNICATIONSOUTLET + + +dataoutlet = IfcOutletTypeEnum.DATAOUTLET + + +poweroutlet = IfcOutletTypeEnum.POWEROUTLET + + +telephoneoutlet = IfcOutletTypeEnum.TELEPHONEOUTLET + + +userdefined = IfcOutletTypeEnum.USERDEFINED + + +notdefined = IfcOutletTypeEnum.NOTDEFINED + + +IfcPavementTypeEnum = enum_namespace() + + +flexible = IfcPavementTypeEnum.FLEXIBLE + + +rigid = IfcPavementTypeEnum.RIGID + + +userdefined = IfcPavementTypeEnum.USERDEFINED + + +notdefined = IfcPavementTypeEnum.NOTDEFINED + + +IfcPerformanceHistoryTypeEnum = enum_namespace() + + +userdefined = IfcPerformanceHistoryTypeEnum.USERDEFINED + + +notdefined = IfcPerformanceHistoryTypeEnum.NOTDEFINED + + +IfcPermeableCoveringOperationEnum = enum_namespace() + + +grill = IfcPermeableCoveringOperationEnum.GRILL + + +louver = IfcPermeableCoveringOperationEnum.LOUVER + + +screen = IfcPermeableCoveringOperationEnum.SCREEN + + +userdefined = IfcPermeableCoveringOperationEnum.USERDEFINED + + +notdefined = IfcPermeableCoveringOperationEnum.NOTDEFINED + + +IfcPermitTypeEnum = enum_namespace() + + +access = IfcPermitTypeEnum.ACCESS + + +building = IfcPermitTypeEnum.BUILDING + + +work = IfcPermitTypeEnum.WORK + + +userdefined = IfcPermitTypeEnum.USERDEFINED + + +notdefined = IfcPermitTypeEnum.NOTDEFINED + + +IfcPhysicalOrVirtualEnum = enum_namespace() + + +physical = IfcPhysicalOrVirtualEnum.PHYSICAL + + +virtual = IfcPhysicalOrVirtualEnum.VIRTUAL + + +notdefined = IfcPhysicalOrVirtualEnum.NOTDEFINED + + +IfcPileConstructionEnum = enum_namespace() + + +cast_in_place = IfcPileConstructionEnum.CAST_IN_PLACE + + +composite = IfcPileConstructionEnum.COMPOSITE + + +precast_concrete = IfcPileConstructionEnum.PRECAST_CONCRETE + + +prefab_steel = IfcPileConstructionEnum.PREFAB_STEEL + + +userdefined = IfcPileConstructionEnum.USERDEFINED + + +notdefined = IfcPileConstructionEnum.NOTDEFINED + + +IfcPileTypeEnum = enum_namespace() + + +bored = IfcPileTypeEnum.BORED + + +cohesion = IfcPileTypeEnum.COHESION + + +driven = IfcPileTypeEnum.DRIVEN + + +friction = IfcPileTypeEnum.FRICTION + + +jetgrouting = IfcPileTypeEnum.JETGROUTING + + +support = IfcPileTypeEnum.SUPPORT + + +userdefined = IfcPileTypeEnum.USERDEFINED + + +notdefined = IfcPileTypeEnum.NOTDEFINED + + +IfcPipeFittingTypeEnum = enum_namespace() + + +bend = IfcPipeFittingTypeEnum.BEND + + +connector = IfcPipeFittingTypeEnum.CONNECTOR + + +entry = IfcPipeFittingTypeEnum.ENTRY + + +exit = IfcPipeFittingTypeEnum.EXIT + + +junction = IfcPipeFittingTypeEnum.JUNCTION + + +obstruction = IfcPipeFittingTypeEnum.OBSTRUCTION + + +transition = IfcPipeFittingTypeEnum.TRANSITION + + +userdefined = IfcPipeFittingTypeEnum.USERDEFINED + + +notdefined = IfcPipeFittingTypeEnum.NOTDEFINED + + +IfcPipeSegmentTypeEnum = enum_namespace() + + +culvert = IfcPipeSegmentTypeEnum.CULVERT + + +flexiblesegment = IfcPipeSegmentTypeEnum.FLEXIBLESEGMENT + + +gutter = IfcPipeSegmentTypeEnum.GUTTER + + +rigidsegment = IfcPipeSegmentTypeEnum.RIGIDSEGMENT + + +spool = IfcPipeSegmentTypeEnum.SPOOL + + +userdefined = IfcPipeSegmentTypeEnum.USERDEFINED + + +notdefined = IfcPipeSegmentTypeEnum.NOTDEFINED + + +IfcPlateTypeEnum = enum_namespace() + + +base_plate = IfcPlateTypeEnum.BASE_PLATE + + +cover_plate = IfcPlateTypeEnum.COVER_PLATE + + +curtain_panel = IfcPlateTypeEnum.CURTAIN_PANEL + + +flange_plate = IfcPlateTypeEnum.FLANGE_PLATE + + +gusset_plate = IfcPlateTypeEnum.GUSSET_PLATE + + +sheet = IfcPlateTypeEnum.SHEET + + +splice_plate = IfcPlateTypeEnum.SPLICE_PLATE + + +stiffener_plate = IfcPlateTypeEnum.STIFFENER_PLATE + + +web_plate = IfcPlateTypeEnum.WEB_PLATE + + +userdefined = IfcPlateTypeEnum.USERDEFINED + + +notdefined = IfcPlateTypeEnum.NOTDEFINED + + +IfcPreferredSurfaceCurveRepresentation = enum_namespace() + + +curve3d = IfcPreferredSurfaceCurveRepresentation.CURVE3D + + +pcurve_s1 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S1 + + +pcurve_s2 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S2 + + +IfcProcedureTypeEnum = enum_namespace() + + +advice_caution = IfcProcedureTypeEnum.ADVICE_CAUTION + + +advice_note = IfcProcedureTypeEnum.ADVICE_NOTE + + +advice_warning = IfcProcedureTypeEnum.ADVICE_WARNING + + +calibration = IfcProcedureTypeEnum.CALIBRATION + + +diagnostic = IfcProcedureTypeEnum.DIAGNOSTIC + + +shutdown = IfcProcedureTypeEnum.SHUTDOWN + + +startup = IfcProcedureTypeEnum.STARTUP + + +userdefined = IfcProcedureTypeEnum.USERDEFINED + + +notdefined = IfcProcedureTypeEnum.NOTDEFINED + + +IfcProfileTypeEnum = enum_namespace() + + +area = IfcProfileTypeEnum.AREA + + +curve = IfcProfileTypeEnum.CURVE + + +IfcProjectOrderTypeEnum = enum_namespace() + + +changeorder = IfcProjectOrderTypeEnum.CHANGEORDER + + +maintenanceworkorder = IfcProjectOrderTypeEnum.MAINTENANCEWORKORDER + + +moveorder = IfcProjectOrderTypeEnum.MOVEORDER + + +purchaseorder = IfcProjectOrderTypeEnum.PURCHASEORDER + + +workorder = IfcProjectOrderTypeEnum.WORKORDER + + +userdefined = IfcProjectOrderTypeEnum.USERDEFINED + + +notdefined = IfcProjectOrderTypeEnum.NOTDEFINED + + +IfcProjectedOrTrueLengthEnum = enum_namespace() + + +projected_length = IfcProjectedOrTrueLengthEnum.PROJECTED_LENGTH + + +true_length = IfcProjectedOrTrueLengthEnum.TRUE_LENGTH + + +IfcProjectionElementTypeEnum = enum_namespace() + + +blister = IfcProjectionElementTypeEnum.BLISTER + + +deviator = IfcProjectionElementTypeEnum.DEVIATOR + + +userdefined = IfcProjectionElementTypeEnum.USERDEFINED + + +notdefined = IfcProjectionElementTypeEnum.NOTDEFINED + + +IfcPropertySetTemplateTypeEnum = enum_namespace() + + +pset_materialdriven = IfcPropertySetTemplateTypeEnum.PSET_MATERIALDRIVEN + + +pset_occurrencedriven = IfcPropertySetTemplateTypeEnum.PSET_OCCURRENCEDRIVEN + + +pset_performancedriven = IfcPropertySetTemplateTypeEnum.PSET_PERFORMANCEDRIVEN + + +pset_profiledriven = IfcPropertySetTemplateTypeEnum.PSET_PROFILEDRIVEN + + +pset_typedrivenonly = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENONLY + + +pset_typedrivenoverride = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENOVERRIDE + + +qto_occurrencedriven = IfcPropertySetTemplateTypeEnum.QTO_OCCURRENCEDRIVEN + + +qto_typedrivenonly = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENONLY + + +qto_typedrivenoverride = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENOVERRIDE + + +notdefined = IfcPropertySetTemplateTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTrippingUnitTypeEnum = enum_namespace() + + +electromagnetic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTROMAGNETIC + + +electronic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTRONIC + + +residualcurrent = IfcProtectiveDeviceTrippingUnitTypeEnum.RESIDUALCURRENT + + +thermal = IfcProtectiveDeviceTrippingUnitTypeEnum.THERMAL + + +userdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTypeEnum = enum_namespace() + + +anti_arcing_device = IfcProtectiveDeviceTypeEnum.ANTI_ARCING_DEVICE + + +circuitbreaker = IfcProtectiveDeviceTypeEnum.CIRCUITBREAKER + + +earthingswitch = IfcProtectiveDeviceTypeEnum.EARTHINGSWITCH + + +earthleakagecircuitbreaker = IfcProtectiveDeviceTypeEnum.EARTHLEAKAGECIRCUITBREAKER + + +fusedisconnector = IfcProtectiveDeviceTypeEnum.FUSEDISCONNECTOR + + +residualcurrentcircuitbreaker = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTCIRCUITBREAKER + + +residualcurrentswitch = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTSWITCH + + +sparkgap = IfcProtectiveDeviceTypeEnum.SPARKGAP + + +varistor = IfcProtectiveDeviceTypeEnum.VARISTOR + + +voltagelimiter = IfcProtectiveDeviceTypeEnum.VOLTAGELIMITER + + +userdefined = IfcProtectiveDeviceTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTypeEnum.NOTDEFINED + + +IfcPumpTypeEnum = enum_namespace() + + +circulator = IfcPumpTypeEnum.CIRCULATOR + + +endsuction = IfcPumpTypeEnum.ENDSUCTION + + +splitcase = IfcPumpTypeEnum.SPLITCASE + + +submersiblepump = IfcPumpTypeEnum.SUBMERSIBLEPUMP + + +sumppump = IfcPumpTypeEnum.SUMPPUMP + + +verticalinline = IfcPumpTypeEnum.VERTICALINLINE + + +verticalturbine = IfcPumpTypeEnum.VERTICALTURBINE + + +userdefined = IfcPumpTypeEnum.USERDEFINED + + +notdefined = IfcPumpTypeEnum.NOTDEFINED + + +IfcRailTypeEnum = enum_namespace() + + +blade = IfcRailTypeEnum.BLADE + + +checkrail = IfcRailTypeEnum.CHECKRAIL + + +guardrail = IfcRailTypeEnum.GUARDRAIL + + +rackrail = IfcRailTypeEnum.RACKRAIL + + +rail = IfcRailTypeEnum.RAIL + + +stockrail = IfcRailTypeEnum.STOCKRAIL + + +userdefined = IfcRailTypeEnum.USERDEFINED + + +notdefined = IfcRailTypeEnum.NOTDEFINED + + +IfcRailingTypeEnum = enum_namespace() + + +balustrade = IfcRailingTypeEnum.BALUSTRADE + + +fence = IfcRailingTypeEnum.FENCE + + +guardrail = IfcRailingTypeEnum.GUARDRAIL + + +handrail = IfcRailingTypeEnum.HANDRAIL + + +userdefined = IfcRailingTypeEnum.USERDEFINED + + +notdefined = IfcRailingTypeEnum.NOTDEFINED + + +IfcRailwayPartTypeEnum = enum_namespace() + + +dilatationsuperstructure = IfcRailwayPartTypeEnum.DILATATIONSUPERSTRUCTURE + + +linesidestructure = IfcRailwayPartTypeEnum.LINESIDESTRUCTURE + + +linesidestructurepart = IfcRailwayPartTypeEnum.LINESIDESTRUCTUREPART + + +plaintracksuperstructure = IfcRailwayPartTypeEnum.PLAINTRACKSUPERSTRUCTURE + + +superstructure = IfcRailwayPartTypeEnum.SUPERSTRUCTURE + + +trackstructure = IfcRailwayPartTypeEnum.TRACKSTRUCTURE + + +trackstructurepart = IfcRailwayPartTypeEnum.TRACKSTRUCTUREPART + + +turnoutsuperstructure = IfcRailwayPartTypeEnum.TURNOUTSUPERSTRUCTURE + + +userdefined = IfcRailwayPartTypeEnum.USERDEFINED + + +notdefined = IfcRailwayPartTypeEnum.NOTDEFINED + + +IfcRailwayTypeEnum = enum_namespace() + + +userdefined = IfcRailwayTypeEnum.USERDEFINED + + +notdefined = IfcRailwayTypeEnum.NOTDEFINED + + +IfcRampFlightTypeEnum = enum_namespace() + + +spiral = IfcRampFlightTypeEnum.SPIRAL + + +straight = IfcRampFlightTypeEnum.STRAIGHT + + +userdefined = IfcRampFlightTypeEnum.USERDEFINED + + +notdefined = IfcRampFlightTypeEnum.NOTDEFINED + + +IfcRampTypeEnum = enum_namespace() + + +half_turn_ramp = IfcRampTypeEnum.HALF_TURN_RAMP + + +quarter_turn_ramp = IfcRampTypeEnum.QUARTER_TURN_RAMP + + +spiral_ramp = IfcRampTypeEnum.SPIRAL_RAMP + + +straight_run_ramp = IfcRampTypeEnum.STRAIGHT_RUN_RAMP + + +two_quarter_turn_ramp = IfcRampTypeEnum.TWO_QUARTER_TURN_RAMP + + +two_straight_run_ramp = IfcRampTypeEnum.TWO_STRAIGHT_RUN_RAMP + + +userdefined = IfcRampTypeEnum.USERDEFINED + + +notdefined = IfcRampTypeEnum.NOTDEFINED + + +IfcRecurrenceTypeEnum = enum_namespace() + + +by_day_count = IfcRecurrenceTypeEnum.BY_DAY_COUNT + + +by_weekday_count = IfcRecurrenceTypeEnum.BY_WEEKDAY_COUNT + + +daily = IfcRecurrenceTypeEnum.DAILY + + +monthly_by_day_of_month = IfcRecurrenceTypeEnum.MONTHLY_BY_DAY_OF_MONTH + + +monthly_by_position = IfcRecurrenceTypeEnum.MONTHLY_BY_POSITION + + +weekly = IfcRecurrenceTypeEnum.WEEKLY + + +yearly_by_day_of_month = IfcRecurrenceTypeEnum.YEARLY_BY_DAY_OF_MONTH + + +yearly_by_position = IfcRecurrenceTypeEnum.YEARLY_BY_POSITION + + +IfcReferentTypeEnum = enum_namespace() + + +boundary = IfcReferentTypeEnum.BOUNDARY + + +intersection = IfcReferentTypeEnum.INTERSECTION + + +kilopoint = IfcReferentTypeEnum.KILOPOINT + + +landmark = IfcReferentTypeEnum.LANDMARK + + +milepoint = IfcReferentTypeEnum.MILEPOINT + + +position = IfcReferentTypeEnum.POSITION + + +referencemarker = IfcReferentTypeEnum.REFERENCEMARKER + + +station = IfcReferentTypeEnum.STATION + + +userdefined = IfcReferentTypeEnum.USERDEFINED + + +notdefined = IfcReferentTypeEnum.NOTDEFINED + + +IfcReflectanceMethodEnum = enum_namespace() + + +blinn = IfcReflectanceMethodEnum.BLINN + + +flat = IfcReflectanceMethodEnum.FLAT + + +glass = IfcReflectanceMethodEnum.GLASS + + +matt = IfcReflectanceMethodEnum.MATT + + +metal = IfcReflectanceMethodEnum.METAL + + +mirror = IfcReflectanceMethodEnum.MIRROR + + +phong = IfcReflectanceMethodEnum.PHONG + + +physical = IfcReflectanceMethodEnum.PHYSICAL + + +plastic = IfcReflectanceMethodEnum.PLASTIC + + +strauss = IfcReflectanceMethodEnum.STRAUSS + + +notdefined = IfcReflectanceMethodEnum.NOTDEFINED + + +IfcReinforcedSoilTypeEnum = enum_namespace() + + +dynamicallycompacted = IfcReinforcedSoilTypeEnum.DYNAMICALLYCOMPACTED + + +grouted = IfcReinforcedSoilTypeEnum.GROUTED + + +replaced = IfcReinforcedSoilTypeEnum.REPLACED + + +rollercompacted = IfcReinforcedSoilTypeEnum.ROLLERCOMPACTED + + +surchargepreloaded = IfcReinforcedSoilTypeEnum.SURCHARGEPRELOADED + + +verticallydrained = IfcReinforcedSoilTypeEnum.VERTICALLYDRAINED + + +userdefined = IfcReinforcedSoilTypeEnum.USERDEFINED + + +notdefined = IfcReinforcedSoilTypeEnum.NOTDEFINED + + +IfcReinforcingBarRoleEnum = enum_namespace() + + +anchoring = IfcReinforcingBarRoleEnum.ANCHORING + + +edge = IfcReinforcingBarRoleEnum.EDGE + + +ligature = IfcReinforcingBarRoleEnum.LIGATURE + + +main = IfcReinforcingBarRoleEnum.MAIN + + +punching = IfcReinforcingBarRoleEnum.PUNCHING + + +ring = IfcReinforcingBarRoleEnum.RING + + +shear = IfcReinforcingBarRoleEnum.SHEAR + + +stud = IfcReinforcingBarRoleEnum.STUD + + +userdefined = IfcReinforcingBarRoleEnum.USERDEFINED + + +notdefined = IfcReinforcingBarRoleEnum.NOTDEFINED + + +IfcReinforcingBarSurfaceEnum = enum_namespace() + + +plain = IfcReinforcingBarSurfaceEnum.PLAIN + + +textured = IfcReinforcingBarSurfaceEnum.TEXTURED + + +IfcReinforcingBarTypeEnum = enum_namespace() + + +anchoring = IfcReinforcingBarTypeEnum.ANCHORING + + +edge = IfcReinforcingBarTypeEnum.EDGE + + +ligature = IfcReinforcingBarTypeEnum.LIGATURE + + +main = IfcReinforcingBarTypeEnum.MAIN + + +punching = IfcReinforcingBarTypeEnum.PUNCHING + + +ring = IfcReinforcingBarTypeEnum.RING + + +shear = IfcReinforcingBarTypeEnum.SHEAR + + +spacebar = IfcReinforcingBarTypeEnum.SPACEBAR + + +stud = IfcReinforcingBarTypeEnum.STUD + + +userdefined = IfcReinforcingBarTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingBarTypeEnum.NOTDEFINED + + +IfcReinforcingMeshTypeEnum = enum_namespace() + + +userdefined = IfcReinforcingMeshTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingMeshTypeEnum.NOTDEFINED + + +IfcRoadPartTypeEnum = enum_namespace() + + +bicyclecrossing = IfcRoadPartTypeEnum.BICYCLECROSSING + + +bus_stop = IfcRoadPartTypeEnum.BUS_STOP + + +carriageway = IfcRoadPartTypeEnum.CARRIAGEWAY + + +centralisland = IfcRoadPartTypeEnum.CENTRALISLAND + + +centralreserve = IfcRoadPartTypeEnum.CENTRALRESERVE + + +hardshoulder = IfcRoadPartTypeEnum.HARDSHOULDER + + +intersection = IfcRoadPartTypeEnum.INTERSECTION + + +layby = IfcRoadPartTypeEnum.LAYBY + + +parkingbay = IfcRoadPartTypeEnum.PARKINGBAY + + +passingbay = IfcRoadPartTypeEnum.PASSINGBAY + + +pedestrian_crossing = IfcRoadPartTypeEnum.PEDESTRIAN_CROSSING + + +railwaycrossing = IfcRoadPartTypeEnum.RAILWAYCROSSING + + +refugeisland = IfcRoadPartTypeEnum.REFUGEISLAND + + +roadsegment = IfcRoadPartTypeEnum.ROADSEGMENT + + +roadside = IfcRoadPartTypeEnum.ROADSIDE + + +roadsidepart = IfcRoadPartTypeEnum.ROADSIDEPART + + +roadwayplateau = IfcRoadPartTypeEnum.ROADWAYPLATEAU + + +roundabout = IfcRoadPartTypeEnum.ROUNDABOUT + + +shoulder = IfcRoadPartTypeEnum.SHOULDER + + +sidewalk = IfcRoadPartTypeEnum.SIDEWALK + + +softshoulder = IfcRoadPartTypeEnum.SOFTSHOULDER + + +tollplaza = IfcRoadPartTypeEnum.TOLLPLAZA + + +trafficisland = IfcRoadPartTypeEnum.TRAFFICISLAND + + +trafficlane = IfcRoadPartTypeEnum.TRAFFICLANE + + +userdefined = IfcRoadPartTypeEnum.USERDEFINED + + +notdefined = IfcRoadPartTypeEnum.NOTDEFINED + + +IfcRoadTypeEnum = enum_namespace() + + +userdefined = IfcRoadTypeEnum.USERDEFINED + + +notdefined = IfcRoadTypeEnum.NOTDEFINED + + +IfcRoleEnum = enum_namespace() + + +architect = IfcRoleEnum.ARCHITECT + + +buildingoperator = IfcRoleEnum.BUILDINGOPERATOR + + +buildingowner = IfcRoleEnum.BUILDINGOWNER + + +civilengineer = IfcRoleEnum.CIVILENGINEER + + +client = IfcRoleEnum.CLIENT + + +commissioningengineer = IfcRoleEnum.COMMISSIONINGENGINEER + + +constructionmanager = IfcRoleEnum.CONSTRUCTIONMANAGER + + +consultant = IfcRoleEnum.CONSULTANT + + +contractor = IfcRoleEnum.CONTRACTOR + + +costengineer = IfcRoleEnum.COSTENGINEER + + +electricalengineer = IfcRoleEnum.ELECTRICALENGINEER + + +engineer = IfcRoleEnum.ENGINEER + + +facilitiesmanager = IfcRoleEnum.FACILITIESMANAGER + + +fieldconstructionmanager = IfcRoleEnum.FIELDCONSTRUCTIONMANAGER + + +manufacturer = IfcRoleEnum.MANUFACTURER + + +mechanicalengineer = IfcRoleEnum.MECHANICALENGINEER + + +owner = IfcRoleEnum.OWNER + + +projectmanager = IfcRoleEnum.PROJECTMANAGER + + +reseller = IfcRoleEnum.RESELLER + + +structuralengineer = IfcRoleEnum.STRUCTURALENGINEER + + +subcontractor = IfcRoleEnum.SUBCONTRACTOR + + +supplier = IfcRoleEnum.SUPPLIER + + +userdefined = IfcRoleEnum.USERDEFINED + + +IfcRoofTypeEnum = enum_namespace() + + +barrel_roof = IfcRoofTypeEnum.BARREL_ROOF + + +butterfly_roof = IfcRoofTypeEnum.BUTTERFLY_ROOF + + +dome_roof = IfcRoofTypeEnum.DOME_ROOF + + +flat_roof = IfcRoofTypeEnum.FLAT_ROOF + + +freeform = IfcRoofTypeEnum.FREEFORM + + +gable_roof = IfcRoofTypeEnum.GABLE_ROOF + + +gambrel_roof = IfcRoofTypeEnum.GAMBREL_ROOF + + +hipped_gable_roof = IfcRoofTypeEnum.HIPPED_GABLE_ROOF + + +hip_roof = IfcRoofTypeEnum.HIP_ROOF + + +mansard_roof = IfcRoofTypeEnum.MANSARD_ROOF + + +pavilion_roof = IfcRoofTypeEnum.PAVILION_ROOF + + +rainbow_roof = IfcRoofTypeEnum.RAINBOW_ROOF + + +shed_roof = IfcRoofTypeEnum.SHED_ROOF + + +userdefined = IfcRoofTypeEnum.USERDEFINED + + +notdefined = IfcRoofTypeEnum.NOTDEFINED + + +IfcSIPrefix = enum_namespace() + + +atto = IfcSIPrefix.ATTO + + +centi = IfcSIPrefix.CENTI + + +deca = IfcSIPrefix.DECA + + +deci = IfcSIPrefix.DECI + + +exa = IfcSIPrefix.EXA + + +femto = IfcSIPrefix.FEMTO + + +giga = IfcSIPrefix.GIGA + + +hecto = IfcSIPrefix.HECTO + + +kilo = IfcSIPrefix.KILO + + +mega = IfcSIPrefix.MEGA + + +micro = IfcSIPrefix.MICRO + + +milli = IfcSIPrefix.MILLI + + +nano = IfcSIPrefix.NANO + + +peta = IfcSIPrefix.PETA + + +pico = IfcSIPrefix.PICO + + +tera = IfcSIPrefix.TERA + + +IfcSIUnitName = enum_namespace() + + +ampere = IfcSIUnitName.AMPERE + + +becquerel = IfcSIUnitName.BECQUEREL + + +candela = IfcSIUnitName.CANDELA + + +coulomb = IfcSIUnitName.COULOMB + + +cubic_metre = IfcSIUnitName.CUBIC_METRE + + +degree_celsius = IfcSIUnitName.DEGREE_CELSIUS + + +farad = IfcSIUnitName.FARAD + + +gram = IfcSIUnitName.GRAM + + +gray = IfcSIUnitName.GRAY + + +henry = IfcSIUnitName.HENRY + + +hertz = IfcSIUnitName.HERTZ + + +joule = IfcSIUnitName.JOULE + + +kelvin = IfcSIUnitName.KELVIN + + +lumen = IfcSIUnitName.LUMEN + + +lux = IfcSIUnitName.LUX + + +metre = IfcSIUnitName.METRE + + +mole = IfcSIUnitName.MOLE + + +newton = IfcSIUnitName.NEWTON + + +ohm = IfcSIUnitName.OHM + + +pascal = IfcSIUnitName.PASCAL + + +radian = IfcSIUnitName.RADIAN + + +second = IfcSIUnitName.SECOND + + +siemens = IfcSIUnitName.SIEMENS + + +sievert = IfcSIUnitName.SIEVERT + + +square_metre = IfcSIUnitName.SQUARE_METRE + + +steradian = IfcSIUnitName.STERADIAN + + +tesla = IfcSIUnitName.TESLA + + +volt = IfcSIUnitName.VOLT + + +watt = IfcSIUnitName.WATT + + +weber = IfcSIUnitName.WEBER + + +IfcSanitaryTerminalTypeEnum = enum_namespace() + + +bath = IfcSanitaryTerminalTypeEnum.BATH + + +bidet = IfcSanitaryTerminalTypeEnum.BIDET + + +cistern = IfcSanitaryTerminalTypeEnum.CISTERN + + +sanitaryfountain = IfcSanitaryTerminalTypeEnum.SANITARYFOUNTAIN + + +shower = IfcSanitaryTerminalTypeEnum.SHOWER + + +sink = IfcSanitaryTerminalTypeEnum.SINK + + +toiletpan = IfcSanitaryTerminalTypeEnum.TOILETPAN + + +urinal = IfcSanitaryTerminalTypeEnum.URINAL + + +washhandbasin = IfcSanitaryTerminalTypeEnum.WASHHANDBASIN + + +wcseat = IfcSanitaryTerminalTypeEnum.WCSEAT + + +userdefined = IfcSanitaryTerminalTypeEnum.USERDEFINED + + +notdefined = IfcSanitaryTerminalTypeEnum.NOTDEFINED + + +IfcSectionTypeEnum = enum_namespace() + + +tapered = IfcSectionTypeEnum.TAPERED + + +uniform = IfcSectionTypeEnum.UNIFORM + + +IfcSensorTypeEnum = enum_namespace() + + +co2sensor = IfcSensorTypeEnum.CO2SENSOR + + +conductancesensor = IfcSensorTypeEnum.CONDUCTANCESENSOR + + +contactsensor = IfcSensorTypeEnum.CONTACTSENSOR + + +cosensor = IfcSensorTypeEnum.COSENSOR + + +earthquakesensor = IfcSensorTypeEnum.EARTHQUAKESENSOR + + +firesensor = IfcSensorTypeEnum.FIRESENSOR + + +flowsensor = IfcSensorTypeEnum.FLOWSENSOR + + +foreignobjectdetectionsensor = IfcSensorTypeEnum.FOREIGNOBJECTDETECTIONSENSOR + + +frostsensor = IfcSensorTypeEnum.FROSTSENSOR + + +gassensor = IfcSensorTypeEnum.GASSENSOR + + +heatsensor = IfcSensorTypeEnum.HEATSENSOR + + +humiditysensor = IfcSensorTypeEnum.HUMIDITYSENSOR + + +identifiersensor = IfcSensorTypeEnum.IDENTIFIERSENSOR + + +ionconcentrationsensor = IfcSensorTypeEnum.IONCONCENTRATIONSENSOR + + +levelsensor = IfcSensorTypeEnum.LEVELSENSOR + + +lightsensor = IfcSensorTypeEnum.LIGHTSENSOR + + +moisturesensor = IfcSensorTypeEnum.MOISTURESENSOR + + +movementsensor = IfcSensorTypeEnum.MOVEMENTSENSOR + + +obstaclesensor = IfcSensorTypeEnum.OBSTACLESENSOR + + +phsensor = IfcSensorTypeEnum.PHSENSOR + + +pressuresensor = IfcSensorTypeEnum.PRESSURESENSOR + + +radiationsensor = IfcSensorTypeEnum.RADIATIONSENSOR + + +radioactivitysensor = IfcSensorTypeEnum.RADIOACTIVITYSENSOR + + +rainsensor = IfcSensorTypeEnum.RAINSENSOR + + +smokesensor = IfcSensorTypeEnum.SMOKESENSOR + + +snowdepthsensor = IfcSensorTypeEnum.SNOWDEPTHSENSOR + + +soundsensor = IfcSensorTypeEnum.SOUNDSENSOR + + +temperaturesensor = IfcSensorTypeEnum.TEMPERATURESENSOR + + +trainsensor = IfcSensorTypeEnum.TRAINSENSOR + + +turnoutclosuresensor = IfcSensorTypeEnum.TURNOUTCLOSURESENSOR + + +wheelsensor = IfcSensorTypeEnum.WHEELSENSOR + + +windsensor = IfcSensorTypeEnum.WINDSENSOR + + +userdefined = IfcSensorTypeEnum.USERDEFINED + + +notdefined = IfcSensorTypeEnum.NOTDEFINED + + +IfcSequenceEnum = enum_namespace() + + +finish_finish = IfcSequenceEnum.FINISH_FINISH + + +finish_start = IfcSequenceEnum.FINISH_START + + +start_finish = IfcSequenceEnum.START_FINISH + + +start_start = IfcSequenceEnum.START_START + + +userdefined = IfcSequenceEnum.USERDEFINED + + +notdefined = IfcSequenceEnum.NOTDEFINED + + +IfcShadingDeviceTypeEnum = enum_namespace() + + +awning = IfcShadingDeviceTypeEnum.AWNING + + +jalousie = IfcShadingDeviceTypeEnum.JALOUSIE + + +shutter = IfcShadingDeviceTypeEnum.SHUTTER + + +userdefined = IfcShadingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcShadingDeviceTypeEnum.NOTDEFINED + + +IfcSignTypeEnum = enum_namespace() + + +marker = IfcSignTypeEnum.MARKER + + +mirror = IfcSignTypeEnum.MIRROR + + +pictoral = IfcSignTypeEnum.PICTORAL + + +userdefined = IfcSignTypeEnum.USERDEFINED + + +notdefined = IfcSignTypeEnum.NOTDEFINED + + +IfcSignalTypeEnum = enum_namespace() + + +audio = IfcSignalTypeEnum.AUDIO + + +mixed = IfcSignalTypeEnum.MIXED + + +visual = IfcSignalTypeEnum.VISUAL + + +userdefined = IfcSignalTypeEnum.USERDEFINED + + +notdefined = IfcSignalTypeEnum.NOTDEFINED + + +IfcSimplePropertyTemplateTypeEnum = enum_namespace() + + +p_boundedvalue = IfcSimplePropertyTemplateTypeEnum.P_BOUNDEDVALUE + + +p_enumeratedvalue = IfcSimplePropertyTemplateTypeEnum.P_ENUMERATEDVALUE + + +p_listvalue = IfcSimplePropertyTemplateTypeEnum.P_LISTVALUE + + +p_referencevalue = IfcSimplePropertyTemplateTypeEnum.P_REFERENCEVALUE + + +p_singlevalue = IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE + + +p_tablevalue = IfcSimplePropertyTemplateTypeEnum.P_TABLEVALUE + + +q_area = IfcSimplePropertyTemplateTypeEnum.Q_AREA + + +q_count = IfcSimplePropertyTemplateTypeEnum.Q_COUNT + + +q_length = IfcSimplePropertyTemplateTypeEnum.Q_LENGTH + + +q_number = IfcSimplePropertyTemplateTypeEnum.Q_NUMBER + + +q_time = IfcSimplePropertyTemplateTypeEnum.Q_TIME + + +q_volume = IfcSimplePropertyTemplateTypeEnum.Q_VOLUME + + +q_weight = IfcSimplePropertyTemplateTypeEnum.Q_WEIGHT + + +IfcSlabTypeEnum = enum_namespace() + + +approach_slab = IfcSlabTypeEnum.APPROACH_SLAB + + +baseslab = IfcSlabTypeEnum.BASESLAB + + +floor = IfcSlabTypeEnum.FLOOR + + +landing = IfcSlabTypeEnum.LANDING + + +paving = IfcSlabTypeEnum.PAVING + + +roof = IfcSlabTypeEnum.ROOF + + +sidewalk = IfcSlabTypeEnum.SIDEWALK + + +trackslab = IfcSlabTypeEnum.TRACKSLAB + + +wearing = IfcSlabTypeEnum.WEARING + + +userdefined = IfcSlabTypeEnum.USERDEFINED + + +notdefined = IfcSlabTypeEnum.NOTDEFINED + + +IfcSolarDeviceTypeEnum = enum_namespace() + + +solarcollector = IfcSolarDeviceTypeEnum.SOLARCOLLECTOR + + +solarpanel = IfcSolarDeviceTypeEnum.SOLARPANEL + + +userdefined = IfcSolarDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSolarDeviceTypeEnum.NOTDEFINED + + +IfcSpaceHeaterTypeEnum = enum_namespace() + + +convector = IfcSpaceHeaterTypeEnum.CONVECTOR + + +radiator = IfcSpaceHeaterTypeEnum.RADIATOR + + +userdefined = IfcSpaceHeaterTypeEnum.USERDEFINED + + +notdefined = IfcSpaceHeaterTypeEnum.NOTDEFINED + + +IfcSpaceTypeEnum = enum_namespace() + + +berth = IfcSpaceTypeEnum.BERTH + + +external = IfcSpaceTypeEnum.EXTERNAL + + +gfa = IfcSpaceTypeEnum.GFA + + +internal = IfcSpaceTypeEnum.INTERNAL + + +parking = IfcSpaceTypeEnum.PARKING + + +space = IfcSpaceTypeEnum.SPACE + + +userdefined = IfcSpaceTypeEnum.USERDEFINED + + +notdefined = IfcSpaceTypeEnum.NOTDEFINED + + +IfcSpatialZoneTypeEnum = enum_namespace() + + +construction = IfcSpatialZoneTypeEnum.CONSTRUCTION + + +firesafety = IfcSpatialZoneTypeEnum.FIRESAFETY + + +interference = IfcSpatialZoneTypeEnum.INTERFERENCE + + +lighting = IfcSpatialZoneTypeEnum.LIGHTING + + +occupancy = IfcSpatialZoneTypeEnum.OCCUPANCY + + +reservation = IfcSpatialZoneTypeEnum.RESERVATION + + +security = IfcSpatialZoneTypeEnum.SECURITY + + +thermal = IfcSpatialZoneTypeEnum.THERMAL + + +transport = IfcSpatialZoneTypeEnum.TRANSPORT + + +ventilation = IfcSpatialZoneTypeEnum.VENTILATION + + +userdefined = IfcSpatialZoneTypeEnum.USERDEFINED + + +notdefined = IfcSpatialZoneTypeEnum.NOTDEFINED + + +IfcStackTerminalTypeEnum = enum_namespace() + + +birdcage = IfcStackTerminalTypeEnum.BIRDCAGE + + +cowl = IfcStackTerminalTypeEnum.COWL + + +rainwaterhopper = IfcStackTerminalTypeEnum.RAINWATERHOPPER + + +userdefined = IfcStackTerminalTypeEnum.USERDEFINED + + +notdefined = IfcStackTerminalTypeEnum.NOTDEFINED + + +IfcStairFlightTypeEnum = enum_namespace() + + +curved = IfcStairFlightTypeEnum.CURVED + + +freeform = IfcStairFlightTypeEnum.FREEFORM + + +spiral = IfcStairFlightTypeEnum.SPIRAL + + +straight = IfcStairFlightTypeEnum.STRAIGHT + + +winder = IfcStairFlightTypeEnum.WINDER + + +userdefined = IfcStairFlightTypeEnum.USERDEFINED + + +notdefined = IfcStairFlightTypeEnum.NOTDEFINED + + +IfcStairTypeEnum = enum_namespace() + + +curved_run_stair = IfcStairTypeEnum.CURVED_RUN_STAIR + + +double_return_stair = IfcStairTypeEnum.DOUBLE_RETURN_STAIR + + +half_turn_stair = IfcStairTypeEnum.HALF_TURN_STAIR + + +half_winding_stair = IfcStairTypeEnum.HALF_WINDING_STAIR + + +ladder = IfcStairTypeEnum.LADDER + + +quarter_turn_stair = IfcStairTypeEnum.QUARTER_TURN_STAIR + + +quarter_winding_stair = IfcStairTypeEnum.QUARTER_WINDING_STAIR + + +spiral_stair = IfcStairTypeEnum.SPIRAL_STAIR + + +straight_run_stair = IfcStairTypeEnum.STRAIGHT_RUN_STAIR + + +three_quarter_turn_stair = IfcStairTypeEnum.THREE_QUARTER_TURN_STAIR + + +three_quarter_winding_stair = IfcStairTypeEnum.THREE_QUARTER_WINDING_STAIR + + +two_curved_run_stair = IfcStairTypeEnum.TWO_CURVED_RUN_STAIR + + +two_quarter_turn_stair = IfcStairTypeEnum.TWO_QUARTER_TURN_STAIR + + +two_quarter_winding_stair = IfcStairTypeEnum.TWO_QUARTER_WINDING_STAIR + + +two_straight_run_stair = IfcStairTypeEnum.TWO_STRAIGHT_RUN_STAIR + + +userdefined = IfcStairTypeEnum.USERDEFINED + + +notdefined = IfcStairTypeEnum.NOTDEFINED + + +IfcStateEnum = enum_namespace() + + +locked = IfcStateEnum.LOCKED + + +readonly = IfcStateEnum.READONLY + + +readonlylocked = IfcStateEnum.READONLYLOCKED + + +readwrite = IfcStateEnum.READWRITE + + +readwritelocked = IfcStateEnum.READWRITELOCKED + + +IfcStructuralCurveActivityTypeEnum = enum_namespace() + + +const = IfcStructuralCurveActivityTypeEnum.CONST + + +discrete = IfcStructuralCurveActivityTypeEnum.DISCRETE + + +equidistant = IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + +linear = IfcStructuralCurveActivityTypeEnum.LINEAR + + +parabola = IfcStructuralCurveActivityTypeEnum.PARABOLA + + +polygonal = IfcStructuralCurveActivityTypeEnum.POLYGONAL + + +sinus = IfcStructuralCurveActivityTypeEnum.SINUS + + +userdefined = IfcStructuralCurveActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveActivityTypeEnum.NOTDEFINED + + +IfcStructuralCurveMemberTypeEnum = enum_namespace() + + +cable = IfcStructuralCurveMemberTypeEnum.CABLE + + +compression_member = IfcStructuralCurveMemberTypeEnum.COMPRESSION_MEMBER + + +pin_joined_member = IfcStructuralCurveMemberTypeEnum.PIN_JOINED_MEMBER + + +rigid_joined_member = IfcStructuralCurveMemberTypeEnum.RIGID_JOINED_MEMBER + + +tension_member = IfcStructuralCurveMemberTypeEnum.TENSION_MEMBER + + +userdefined = IfcStructuralCurveMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveMemberTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceActivityTypeEnum = enum_namespace() + + +bilinear = IfcStructuralSurfaceActivityTypeEnum.BILINEAR + + +const = IfcStructuralSurfaceActivityTypeEnum.CONST + + +discrete = IfcStructuralSurfaceActivityTypeEnum.DISCRETE + + +isocontour = IfcStructuralSurfaceActivityTypeEnum.ISOCONTOUR + + +userdefined = IfcStructuralSurfaceActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceActivityTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceMemberTypeEnum = enum_namespace() + + +bending_element = IfcStructuralSurfaceMemberTypeEnum.BENDING_ELEMENT + + +membrane_element = IfcStructuralSurfaceMemberTypeEnum.MEMBRANE_ELEMENT + + +shell = IfcStructuralSurfaceMemberTypeEnum.SHELL + + +userdefined = IfcStructuralSurfaceMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceMemberTypeEnum.NOTDEFINED + + +IfcSubContractResourceTypeEnum = enum_namespace() + + +purchase = IfcSubContractResourceTypeEnum.PURCHASE + + +work = IfcSubContractResourceTypeEnum.WORK + + +userdefined = IfcSubContractResourceTypeEnum.USERDEFINED + + +notdefined = IfcSubContractResourceTypeEnum.NOTDEFINED + + +IfcSurfaceFeatureTypeEnum = enum_namespace() + + +defect = IfcSurfaceFeatureTypeEnum.DEFECT + + +hatchmarking = IfcSurfaceFeatureTypeEnum.HATCHMARKING + + +linemarking = IfcSurfaceFeatureTypeEnum.LINEMARKING + + +mark = IfcSurfaceFeatureTypeEnum.MARK + + +nonskidsurfacing = IfcSurfaceFeatureTypeEnum.NONSKIDSURFACING + + +pavementsurfacemarking = IfcSurfaceFeatureTypeEnum.PAVEMENTSURFACEMARKING + + +rumblestrip = IfcSurfaceFeatureTypeEnum.RUMBLESTRIP + + +symbolmarking = IfcSurfaceFeatureTypeEnum.SYMBOLMARKING + + +tag = IfcSurfaceFeatureTypeEnum.TAG + + +transverserumblestrip = IfcSurfaceFeatureTypeEnum.TRANSVERSERUMBLESTRIP + + +treatment = IfcSurfaceFeatureTypeEnum.TREATMENT + + +userdefined = IfcSurfaceFeatureTypeEnum.USERDEFINED + + +notdefined = IfcSurfaceFeatureTypeEnum.NOTDEFINED + + +IfcSurfaceSide = enum_namespace() + + +both = IfcSurfaceSide.BOTH + + +negative = IfcSurfaceSide.NEGATIVE + + +positive = IfcSurfaceSide.POSITIVE + + +IfcSwitchingDeviceTypeEnum = enum_namespace() + + +contactor = IfcSwitchingDeviceTypeEnum.CONTACTOR + + +dimmerswitch = IfcSwitchingDeviceTypeEnum.DIMMERSWITCH + + +emergencystop = IfcSwitchingDeviceTypeEnum.EMERGENCYSTOP + + +keypad = IfcSwitchingDeviceTypeEnum.KEYPAD + + +momentaryswitch = IfcSwitchingDeviceTypeEnum.MOMENTARYSWITCH + + +relay = IfcSwitchingDeviceTypeEnum.RELAY + + +selectorswitch = IfcSwitchingDeviceTypeEnum.SELECTORSWITCH + + +starter = IfcSwitchingDeviceTypeEnum.STARTER + + +start_and_stop_equipment = IfcSwitchingDeviceTypeEnum.START_AND_STOP_EQUIPMENT + + +switchdisconnector = IfcSwitchingDeviceTypeEnum.SWITCHDISCONNECTOR + + +toggleswitch = IfcSwitchingDeviceTypeEnum.TOGGLESWITCH + + +userdefined = IfcSwitchingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSwitchingDeviceTypeEnum.NOTDEFINED + + +IfcSystemFurnitureElementTypeEnum = enum_namespace() + + +panel = IfcSystemFurnitureElementTypeEnum.PANEL + + +subrack = IfcSystemFurnitureElementTypeEnum.SUBRACK + + +worksurface = IfcSystemFurnitureElementTypeEnum.WORKSURFACE + + +userdefined = IfcSystemFurnitureElementTypeEnum.USERDEFINED + + +notdefined = IfcSystemFurnitureElementTypeEnum.NOTDEFINED + + +IfcTankTypeEnum = enum_namespace() + + +basin = IfcTankTypeEnum.BASIN + + +breakpressure = IfcTankTypeEnum.BREAKPRESSURE + + +expansion = IfcTankTypeEnum.EXPANSION + + +feedandexpansion = IfcTankTypeEnum.FEEDANDEXPANSION + + +oilretentiontray = IfcTankTypeEnum.OILRETENTIONTRAY + + +pressurevessel = IfcTankTypeEnum.PRESSUREVESSEL + + +storage = IfcTankTypeEnum.STORAGE + + +vessel = IfcTankTypeEnum.VESSEL + + +userdefined = IfcTankTypeEnum.USERDEFINED + + +notdefined = IfcTankTypeEnum.NOTDEFINED + + +IfcTaskDurationEnum = enum_namespace() + + +elapsedtime = IfcTaskDurationEnum.ELAPSEDTIME + + +worktime = IfcTaskDurationEnum.WORKTIME + + +notdefined = IfcTaskDurationEnum.NOTDEFINED + + +IfcTaskTypeEnum = enum_namespace() + + +adjustment = IfcTaskTypeEnum.ADJUSTMENT + + +attendance = IfcTaskTypeEnum.ATTENDANCE + + +calibration = IfcTaskTypeEnum.CALIBRATION + + +construction = IfcTaskTypeEnum.CONSTRUCTION + + +demolition = IfcTaskTypeEnum.DEMOLITION + + +dismantle = IfcTaskTypeEnum.DISMANTLE + + +disposal = IfcTaskTypeEnum.DISPOSAL + + +emergency = IfcTaskTypeEnum.EMERGENCY + + +inspection = IfcTaskTypeEnum.INSPECTION + + +installation = IfcTaskTypeEnum.INSTALLATION + + +logistic = IfcTaskTypeEnum.LOGISTIC + + +maintenance = IfcTaskTypeEnum.MAINTENANCE + + +move = IfcTaskTypeEnum.MOVE + + +operation = IfcTaskTypeEnum.OPERATION + + +removal = IfcTaskTypeEnum.REMOVAL + + +renovation = IfcTaskTypeEnum.RENOVATION + + +safety = IfcTaskTypeEnum.SAFETY + + +shutdown = IfcTaskTypeEnum.SHUTDOWN + + +startup = IfcTaskTypeEnum.STARTUP + + +testing = IfcTaskTypeEnum.TESTING + + +troubleshooting = IfcTaskTypeEnum.TROUBLESHOOTING + + +userdefined = IfcTaskTypeEnum.USERDEFINED + + +notdefined = IfcTaskTypeEnum.NOTDEFINED + + +IfcTendonAnchorTypeEnum = enum_namespace() + + +coupler = IfcTendonAnchorTypeEnum.COUPLER + + +fixed_end = IfcTendonAnchorTypeEnum.FIXED_END + + +tensioning_end = IfcTendonAnchorTypeEnum.TENSIONING_END + + +userdefined = IfcTendonAnchorTypeEnum.USERDEFINED + + +notdefined = IfcTendonAnchorTypeEnum.NOTDEFINED + + +IfcTendonConduitTypeEnum = enum_namespace() + + +coupler = IfcTendonConduitTypeEnum.COUPLER + + +diabolo = IfcTendonConduitTypeEnum.DIABOLO + + +duct = IfcTendonConduitTypeEnum.DUCT + + +grouting_duct = IfcTendonConduitTypeEnum.GROUTING_DUCT + + +trumpet = IfcTendonConduitTypeEnum.TRUMPET + + +userdefined = IfcTendonConduitTypeEnum.USERDEFINED + + +notdefined = IfcTendonConduitTypeEnum.NOTDEFINED + + +IfcTendonTypeEnum = enum_namespace() + + +bar = IfcTendonTypeEnum.BAR + + +coated = IfcTendonTypeEnum.COATED + + +strand = IfcTendonTypeEnum.STRAND + + +wire = IfcTendonTypeEnum.WIRE + + +userdefined = IfcTendonTypeEnum.USERDEFINED + + +notdefined = IfcTendonTypeEnum.NOTDEFINED + + +IfcTextPath = enum_namespace() + + +down = IfcTextPath.DOWN + + +left = IfcTextPath.LEFT + + +right = IfcTextPath.RIGHT + + +up = IfcTextPath.UP + + +IfcTimeSeriesDataTypeEnum = enum_namespace() + + +continuous = IfcTimeSeriesDataTypeEnum.CONTINUOUS + + +discrete = IfcTimeSeriesDataTypeEnum.DISCRETE + + +discretebinary = IfcTimeSeriesDataTypeEnum.DISCRETEBINARY + + +piecewisebinary = IfcTimeSeriesDataTypeEnum.PIECEWISEBINARY + + +piecewiseconstant = IfcTimeSeriesDataTypeEnum.PIECEWISECONSTANT + + +piecewisecontinuous = IfcTimeSeriesDataTypeEnum.PIECEWISECONTINUOUS + + +notdefined = IfcTimeSeriesDataTypeEnum.NOTDEFINED + + +IfcTrackElementTypeEnum = enum_namespace() + + +blockingdevice = IfcTrackElementTypeEnum.BLOCKINGDEVICE + + +derailer = IfcTrackElementTypeEnum.DERAILER + + +frog = IfcTrackElementTypeEnum.FROG + + +half_set_of_blades = IfcTrackElementTypeEnum.HALF_SET_OF_BLADES + + +sleeper = IfcTrackElementTypeEnum.SLEEPER + + +speedregulator = IfcTrackElementTypeEnum.SPEEDREGULATOR + + +trackendofalignment = IfcTrackElementTypeEnum.TRACKENDOFALIGNMENT + + +vehiclestop = IfcTrackElementTypeEnum.VEHICLESTOP + + +userdefined = IfcTrackElementTypeEnum.USERDEFINED + + +notdefined = IfcTrackElementTypeEnum.NOTDEFINED + + +IfcTransformerTypeEnum = enum_namespace() + + +chopper = IfcTransformerTypeEnum.CHOPPER + + +combined = IfcTransformerTypeEnum.COMBINED + + +current = IfcTransformerTypeEnum.CURRENT + + +frequency = IfcTransformerTypeEnum.FREQUENCY + + +inverter = IfcTransformerTypeEnum.INVERTER + + +rectifier = IfcTransformerTypeEnum.RECTIFIER + + +voltage = IfcTransformerTypeEnum.VOLTAGE + + +userdefined = IfcTransformerTypeEnum.USERDEFINED + + +notdefined = IfcTransformerTypeEnum.NOTDEFINED + + +IfcTransitionCode = enum_namespace() + + +continuous = IfcTransitionCode.CONTINUOUS + + +contsamegradient = IfcTransitionCode.CONTSAMEGRADIENT + + +contsamegradientsamecurvature = IfcTransitionCode.CONTSAMEGRADIENTSAMECURVATURE + + +discontinuous = IfcTransitionCode.DISCONTINUOUS + + +IfcTransportElementTypeEnum = enum_namespace() + + +craneway = IfcTransportElementTypeEnum.CRANEWAY + + +elevator = IfcTransportElementTypeEnum.ELEVATOR + + +escalator = IfcTransportElementTypeEnum.ESCALATOR + + +haulinggear = IfcTransportElementTypeEnum.HAULINGGEAR + + +liftinggear = IfcTransportElementTypeEnum.LIFTINGGEAR + + +movingwalkway = IfcTransportElementTypeEnum.MOVINGWALKWAY + + +userdefined = IfcTransportElementTypeEnum.USERDEFINED + + +notdefined = IfcTransportElementTypeEnum.NOTDEFINED + + +IfcTrimmingPreference = enum_namespace() + + +cartesian = IfcTrimmingPreference.CARTESIAN + + +parameter = IfcTrimmingPreference.PARAMETER + + +unspecified = IfcTrimmingPreference.UNSPECIFIED + + +IfcTubeBundleTypeEnum = enum_namespace() + + +finned = IfcTubeBundleTypeEnum.FINNED + + +userdefined = IfcTubeBundleTypeEnum.USERDEFINED + + +notdefined = IfcTubeBundleTypeEnum.NOTDEFINED + + +IfcUnitEnum = enum_namespace() + + +absorbeddoseunit = IfcUnitEnum.ABSORBEDDOSEUNIT + + +amountofsubstanceunit = IfcUnitEnum.AMOUNTOFSUBSTANCEUNIT + + +areaunit = IfcUnitEnum.AREAUNIT + + +doseequivalentunit = IfcUnitEnum.DOSEEQUIVALENTUNIT + + +electriccapacitanceunit = IfcUnitEnum.ELECTRICCAPACITANCEUNIT + + +electricchargeunit = IfcUnitEnum.ELECTRICCHARGEUNIT + + +electricconductanceunit = IfcUnitEnum.ELECTRICCONDUCTANCEUNIT + + +electriccurrentunit = IfcUnitEnum.ELECTRICCURRENTUNIT + + +electricresistanceunit = IfcUnitEnum.ELECTRICRESISTANCEUNIT + + +electricvoltageunit = IfcUnitEnum.ELECTRICVOLTAGEUNIT + + +energyunit = IfcUnitEnum.ENERGYUNIT + + +forceunit = IfcUnitEnum.FORCEUNIT + + +frequencyunit = IfcUnitEnum.FREQUENCYUNIT + + +illuminanceunit = IfcUnitEnum.ILLUMINANCEUNIT + + +inductanceunit = IfcUnitEnum.INDUCTANCEUNIT + + +lengthunit = IfcUnitEnum.LENGTHUNIT + + +luminousfluxunit = IfcUnitEnum.LUMINOUSFLUXUNIT + + +luminousintensityunit = IfcUnitEnum.LUMINOUSINTENSITYUNIT + + +magneticfluxdensityunit = IfcUnitEnum.MAGNETICFLUXDENSITYUNIT + + +magneticfluxunit = IfcUnitEnum.MAGNETICFLUXUNIT + + +massunit = IfcUnitEnum.MASSUNIT + + +planeangleunit = IfcUnitEnum.PLANEANGLEUNIT + + +powerunit = IfcUnitEnum.POWERUNIT + + +pressureunit = IfcUnitEnum.PRESSUREUNIT + + +radioactivityunit = IfcUnitEnum.RADIOACTIVITYUNIT + + +solidangleunit = IfcUnitEnum.SOLIDANGLEUNIT + + +thermodynamictemperatureunit = IfcUnitEnum.THERMODYNAMICTEMPERATUREUNIT + + +timeunit = IfcUnitEnum.TIMEUNIT + + +volumeunit = IfcUnitEnum.VOLUMEUNIT + + +userdefined = IfcUnitEnum.USERDEFINED + + +IfcUnitaryControlElementTypeEnum = enum_namespace() + + +alarmpanel = IfcUnitaryControlElementTypeEnum.ALARMPANEL + + +basestationcontroller = IfcUnitaryControlElementTypeEnum.BASESTATIONCONTROLLER + + +combined = IfcUnitaryControlElementTypeEnum.COMBINED + + +controlpanel = IfcUnitaryControlElementTypeEnum.CONTROLPANEL + + +gasdetectionpanel = IfcUnitaryControlElementTypeEnum.GASDETECTIONPANEL + + +humidistat = IfcUnitaryControlElementTypeEnum.HUMIDISTAT + + +indicatorpanel = IfcUnitaryControlElementTypeEnum.INDICATORPANEL + + +mimicpanel = IfcUnitaryControlElementTypeEnum.MIMICPANEL + + +thermostat = IfcUnitaryControlElementTypeEnum.THERMOSTAT + + +weatherstation = IfcUnitaryControlElementTypeEnum.WEATHERSTATION + + +userdefined = IfcUnitaryControlElementTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryControlElementTypeEnum.NOTDEFINED + + +IfcUnitaryEquipmentTypeEnum = enum_namespace() + + +airconditioningunit = IfcUnitaryEquipmentTypeEnum.AIRCONDITIONINGUNIT + + +airhandler = IfcUnitaryEquipmentTypeEnum.AIRHANDLER + + +dehumidifier = IfcUnitaryEquipmentTypeEnum.DEHUMIDIFIER + + +rooftopunit = IfcUnitaryEquipmentTypeEnum.ROOFTOPUNIT + + +splitsystem = IfcUnitaryEquipmentTypeEnum.SPLITSYSTEM + + +userdefined = IfcUnitaryEquipmentTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryEquipmentTypeEnum.NOTDEFINED + + +IfcValveTypeEnum = enum_namespace() + + +airrelease = IfcValveTypeEnum.AIRRELEASE + + +antivacuum = IfcValveTypeEnum.ANTIVACUUM + + +changeover = IfcValveTypeEnum.CHANGEOVER + + +check = IfcValveTypeEnum.CHECK + + +commissioning = IfcValveTypeEnum.COMMISSIONING + + +diverting = IfcValveTypeEnum.DIVERTING + + +doublecheck = IfcValveTypeEnum.DOUBLECHECK + + +doubleregulating = IfcValveTypeEnum.DOUBLEREGULATING + + +drawoffcock = IfcValveTypeEnum.DRAWOFFCOCK + + +faucet = IfcValveTypeEnum.FAUCET + + +flushing = IfcValveTypeEnum.FLUSHING + + +gascock = IfcValveTypeEnum.GASCOCK + + +gastap = IfcValveTypeEnum.GASTAP + + +isolating = IfcValveTypeEnum.ISOLATING + + +mixing = IfcValveTypeEnum.MIXING + + +pressurereducing = IfcValveTypeEnum.PRESSUREREDUCING + + +pressurerelief = IfcValveTypeEnum.PRESSURERELIEF + + +regulating = IfcValveTypeEnum.REGULATING + + +safetycutoff = IfcValveTypeEnum.SAFETYCUTOFF + + +steamtrap = IfcValveTypeEnum.STEAMTRAP + + +stopcock = IfcValveTypeEnum.STOPCOCK + + +userdefined = IfcValveTypeEnum.USERDEFINED + + +notdefined = IfcValveTypeEnum.NOTDEFINED + + +IfcVehicleTypeEnum = enum_namespace() + + +cargo = IfcVehicleTypeEnum.CARGO + + +rollingstock = IfcVehicleTypeEnum.ROLLINGSTOCK + + +vehicle = IfcVehicleTypeEnum.VEHICLE + + +vehicleair = IfcVehicleTypeEnum.VEHICLEAIR + + +vehiclemarine = IfcVehicleTypeEnum.VEHICLEMARINE + + +vehicletracked = IfcVehicleTypeEnum.VEHICLETRACKED + + +vehiclewheeled = IfcVehicleTypeEnum.VEHICLEWHEELED + + +userdefined = IfcVehicleTypeEnum.USERDEFINED + + +notdefined = IfcVehicleTypeEnum.NOTDEFINED + + +IfcVibrationDamperTypeEnum = enum_namespace() + + +axial_yield = IfcVibrationDamperTypeEnum.AXIAL_YIELD + + +bending_yield = IfcVibrationDamperTypeEnum.BENDING_YIELD + + +friction = IfcVibrationDamperTypeEnum.FRICTION + + +rubber = IfcVibrationDamperTypeEnum.RUBBER + + +shear_yield = IfcVibrationDamperTypeEnum.SHEAR_YIELD + + +viscous = IfcVibrationDamperTypeEnum.VISCOUS + + +userdefined = IfcVibrationDamperTypeEnum.USERDEFINED + + +notdefined = IfcVibrationDamperTypeEnum.NOTDEFINED + + +IfcVibrationIsolatorTypeEnum = enum_namespace() + + +base = IfcVibrationIsolatorTypeEnum.BASE + + +compression = IfcVibrationIsolatorTypeEnum.COMPRESSION + + +spring = IfcVibrationIsolatorTypeEnum.SPRING + + +userdefined = IfcVibrationIsolatorTypeEnum.USERDEFINED + + +notdefined = IfcVibrationIsolatorTypeEnum.NOTDEFINED + + +IfcVirtualElementTypeEnum = enum_namespace() + + +boundary = IfcVirtualElementTypeEnum.BOUNDARY + + +clearance = IfcVirtualElementTypeEnum.CLEARANCE + + +provisionforvoid = IfcVirtualElementTypeEnum.PROVISIONFORVOID + + +userdefined = IfcVirtualElementTypeEnum.USERDEFINED + + +notdefined = IfcVirtualElementTypeEnum.NOTDEFINED + + +IfcVoidingFeatureTypeEnum = enum_namespace() + + +chamfer = IfcVoidingFeatureTypeEnum.CHAMFER + + +cutout = IfcVoidingFeatureTypeEnum.CUTOUT + + +edge = IfcVoidingFeatureTypeEnum.EDGE + + +hole = IfcVoidingFeatureTypeEnum.HOLE + + +miter = IfcVoidingFeatureTypeEnum.MITER + + +notch = IfcVoidingFeatureTypeEnum.NOTCH + + +userdefined = IfcVoidingFeatureTypeEnum.USERDEFINED + + +notdefined = IfcVoidingFeatureTypeEnum.NOTDEFINED + + +IfcWallTypeEnum = enum_namespace() + + +elementedwall = IfcWallTypeEnum.ELEMENTEDWALL + + +movable = IfcWallTypeEnum.MOVABLE + + +parapet = IfcWallTypeEnum.PARAPET + + +partitioning = IfcWallTypeEnum.PARTITIONING + + +plumbingwall = IfcWallTypeEnum.PLUMBINGWALL + + +polygonal = IfcWallTypeEnum.POLYGONAL + + +retainingwall = IfcWallTypeEnum.RETAININGWALL + + +shear = IfcWallTypeEnum.SHEAR + + +solidwall = IfcWallTypeEnum.SOLIDWALL + + +standard = IfcWallTypeEnum.STANDARD + + +wavewall = IfcWallTypeEnum.WAVEWALL + + +userdefined = IfcWallTypeEnum.USERDEFINED + + +notdefined = IfcWallTypeEnum.NOTDEFINED + + +IfcWasteTerminalTypeEnum = enum_namespace() + + +floortrap = IfcWasteTerminalTypeEnum.FLOORTRAP + + +floorwaste = IfcWasteTerminalTypeEnum.FLOORWASTE + + +gullysump = IfcWasteTerminalTypeEnum.GULLYSUMP + + +gullytrap = IfcWasteTerminalTypeEnum.GULLYTRAP + + +roofdrain = IfcWasteTerminalTypeEnum.ROOFDRAIN + + +wastedisposalunit = IfcWasteTerminalTypeEnum.WASTEDISPOSALUNIT + + +wastetrap = IfcWasteTerminalTypeEnum.WASTETRAP + + +userdefined = IfcWasteTerminalTypeEnum.USERDEFINED + + +notdefined = IfcWasteTerminalTypeEnum.NOTDEFINED + + +IfcWindowPanelOperationEnum = enum_namespace() + + +bottomhung = IfcWindowPanelOperationEnum.BOTTOMHUNG + + +fixedcasement = IfcWindowPanelOperationEnum.FIXEDCASEMENT + + +otheroperation = IfcWindowPanelOperationEnum.OTHEROPERATION + + +pivothorizontal = IfcWindowPanelOperationEnum.PIVOTHORIZONTAL + + +pivotvertical = IfcWindowPanelOperationEnum.PIVOTVERTICAL + + +removablecasement = IfcWindowPanelOperationEnum.REMOVABLECASEMENT + + +sidehunglefthand = IfcWindowPanelOperationEnum.SIDEHUNGLEFTHAND + + +sidehungrighthand = IfcWindowPanelOperationEnum.SIDEHUNGRIGHTHAND + + +slidinghorizontal = IfcWindowPanelOperationEnum.SLIDINGHORIZONTAL + + +slidingvertical = IfcWindowPanelOperationEnum.SLIDINGVERTICAL + + +tiltandturnlefthand = IfcWindowPanelOperationEnum.TILTANDTURNLEFTHAND + + +tiltandturnrighthand = IfcWindowPanelOperationEnum.TILTANDTURNRIGHTHAND + + +tophung = IfcWindowPanelOperationEnum.TOPHUNG + + +notdefined = IfcWindowPanelOperationEnum.NOTDEFINED + + +IfcWindowPanelPositionEnum = enum_namespace() + + +bottom = IfcWindowPanelPositionEnum.BOTTOM + + +left = IfcWindowPanelPositionEnum.LEFT + + +middle = IfcWindowPanelPositionEnum.MIDDLE + + +right = IfcWindowPanelPositionEnum.RIGHT + + +top = IfcWindowPanelPositionEnum.TOP + + +notdefined = IfcWindowPanelPositionEnum.NOTDEFINED + + +IfcWindowStyleConstructionEnum = enum_namespace() + + +aluminium = IfcWindowStyleConstructionEnum.ALUMINIUM + + +aluminium_wood = IfcWindowStyleConstructionEnum.ALUMINIUM_WOOD + + +high_grade_steel = IfcWindowStyleConstructionEnum.HIGH_GRADE_STEEL + + +other_construction = IfcWindowStyleConstructionEnum.OTHER_CONSTRUCTION + + +plastic = IfcWindowStyleConstructionEnum.PLASTIC + + +steel = IfcWindowStyleConstructionEnum.STEEL + + +wood = IfcWindowStyleConstructionEnum.WOOD + + +notdefined = IfcWindowStyleConstructionEnum.NOTDEFINED + + +IfcWindowStyleOperationEnum = enum_namespace() + + +double_panel_horizontal = IfcWindowStyleOperationEnum.DOUBLE_PANEL_HORIZONTAL + + +double_panel_vertical = IfcWindowStyleOperationEnum.DOUBLE_PANEL_VERTICAL + + +single_panel = IfcWindowStyleOperationEnum.SINGLE_PANEL + + +triple_panel_bottom = IfcWindowStyleOperationEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_horizontal = IfcWindowStyleOperationEnum.TRIPLE_PANEL_HORIZONTAL + + +triple_panel_left = IfcWindowStyleOperationEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowStyleOperationEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_top = IfcWindowStyleOperationEnum.TRIPLE_PANEL_TOP + + +triple_panel_vertical = IfcWindowStyleOperationEnum.TRIPLE_PANEL_VERTICAL + + +userdefined = IfcWindowStyleOperationEnum.USERDEFINED + + +notdefined = IfcWindowStyleOperationEnum.NOTDEFINED + + +IfcWindowTypeEnum = enum_namespace() + + +lightdome = IfcWindowTypeEnum.LIGHTDOME + + +skylight = IfcWindowTypeEnum.SKYLIGHT + + +window = IfcWindowTypeEnum.WINDOW + + +userdefined = IfcWindowTypeEnum.USERDEFINED + + +notdefined = IfcWindowTypeEnum.NOTDEFINED + + +IfcWindowTypePartitioningEnum = enum_namespace() + + +double_panel_horizontal = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_HORIZONTAL + + +double_panel_vertical = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_VERTICAL + + +single_panel = IfcWindowTypePartitioningEnum.SINGLE_PANEL + + +triple_panel_bottom = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_horizontal = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_HORIZONTAL + + +triple_panel_left = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_top = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_TOP + + +triple_panel_vertical = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_VERTICAL + + +userdefined = IfcWindowTypePartitioningEnum.USERDEFINED + + +notdefined = IfcWindowTypePartitioningEnum.NOTDEFINED + + +IfcWorkCalendarTypeEnum = enum_namespace() + + +firstshift = IfcWorkCalendarTypeEnum.FIRSTSHIFT + + +secondshift = IfcWorkCalendarTypeEnum.SECONDSHIFT + + +thirdshift = IfcWorkCalendarTypeEnum.THIRDSHIFT + + +userdefined = IfcWorkCalendarTypeEnum.USERDEFINED + + +notdefined = IfcWorkCalendarTypeEnum.NOTDEFINED + + +IfcWorkPlanTypeEnum = enum_namespace() + + +actual = IfcWorkPlanTypeEnum.ACTUAL + + +baseline = IfcWorkPlanTypeEnum.BASELINE + + +planned = IfcWorkPlanTypeEnum.PLANNED + + +userdefined = IfcWorkPlanTypeEnum.USERDEFINED + + +notdefined = IfcWorkPlanTypeEnum.NOTDEFINED + + +IfcWorkScheduleTypeEnum = enum_namespace() + + +actual = IfcWorkScheduleTypeEnum.ACTUAL + + +baseline = IfcWorkScheduleTypeEnum.BASELINE + + +planned = IfcWorkScheduleTypeEnum.PLANNED + + +userdefined = IfcWorkScheduleTypeEnum.USERDEFINED + + +notdefined = IfcWorkScheduleTypeEnum.NOTDEFINED + + +def IfcActionRequest(*args, **kwargs): return ifcopenshell.create_entity('IfcActionRequest', 'IFC4X3', *args, **kwargs) + + +def IfcActor(*args, **kwargs): return ifcopenshell.create_entity('IfcActor', 'IFC4X3', *args, **kwargs) + + +def IfcActorRole(*args, **kwargs): return ifcopenshell.create_entity('IfcActorRole', 'IFC4X3', *args, **kwargs) + + +def IfcActuator(*args, **kwargs): return ifcopenshell.create_entity('IfcActuator', 'IFC4X3', *args, **kwargs) + + +def IfcActuatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcActuatorType', 'IFC4X3', *args, **kwargs) + + +def IfcAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcAddress', 'IFC4X3', *args, **kwargs) + + +def IfcAdvancedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrep', 'IFC4X3', *args, **kwargs) + + +def IfcAdvancedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrepWithVoids', 'IFC4X3', *args, **kwargs) + + +def IfcAdvancedFace(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedFace', 'IFC4X3', *args, **kwargs) + + +def IfcAirTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminal', 'IFC4X3', *args, **kwargs) + + +def IfcAirTerminalBox(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBox', 'IFC4X3', *args, **kwargs) + + +def IfcAirTerminalBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBoxType', 'IFC4X3', *args, **kwargs) + + +def IfcAirTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalType', 'IFC4X3', *args, **kwargs) + + +def IfcAirToAirHeatRecovery(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecovery', 'IFC4X3', *args, **kwargs) + + +def IfcAirToAirHeatRecoveryType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecoveryType', 'IFC4X3', *args, **kwargs) + + +def IfcAlarm(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarm', 'IFC4X3', *args, **kwargs) + + +def IfcAlarmType(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarmType', 'IFC4X3', *args, **kwargs) + + +def IfcAlignment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment', 'IFC4X3', *args, **kwargs) + + +def IfcAlignmentCant(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCant', 'IFC4X3', *args, **kwargs) + + +def IfcAlignmentCantSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCantSegment', 'IFC4X3', *args, **kwargs) + + +def IfcAlignmentHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentHorizontal', 'IFC4X3', *args, **kwargs) + + +def IfcAlignmentHorizontalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentHorizontalSegment', 'IFC4X3', *args, **kwargs) + + +def IfcAlignmentParameterSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentParameterSegment', 'IFC4X3', *args, **kwargs) + + +def IfcAlignmentSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentSegment', 'IFC4X3', *args, **kwargs) + + +def IfcAlignmentVertical(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentVertical', 'IFC4X3', *args, **kwargs) + + +def IfcAlignmentVerticalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentVerticalSegment', 'IFC4X3', *args, **kwargs) + + +def IfcAnnotation(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotation', 'IFC4X3', *args, **kwargs) + + +def IfcAnnotationFillArea(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationFillArea', 'IFC4X3', *args, **kwargs) + + +def IfcApplication(*args, **kwargs): return ifcopenshell.create_entity('IfcApplication', 'IFC4X3', *args, **kwargs) + + +def IfcAppliedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcAppliedValue', 'IFC4X3', *args, **kwargs) + + +def IfcApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcApproval', 'IFC4X3', *args, **kwargs) + + +def IfcApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcApprovalRelationship', 'IFC4X3', *args, **kwargs) + + +def IfcArbitraryClosedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryClosedProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcArbitraryOpenProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryOpenProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcArbitraryProfileDefWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryProfileDefWithVoids', 'IFC4X3', *args, **kwargs) + + +def IfcAsset(*args, **kwargs): return ifcopenshell.create_entity('IfcAsset', 'IFC4X3', *args, **kwargs) + + +def IfcAsymmetricIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcAsymmetricIShapeProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcAudioVisualAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualAppliance', 'IFC4X3', *args, **kwargs) + + +def IfcAudioVisualApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualApplianceType', 'IFC4X3', *args, **kwargs) + + +def IfcAxis1Placement(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis1Placement', 'IFC4X3', *args, **kwargs) + + +def IfcAxis2Placement2D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement2D', 'IFC4X3', *args, **kwargs) + + +def IfcAxis2Placement3D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement3D', 'IFC4X3', *args, **kwargs) + + +def IfcAxis2PlacementLinear(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2PlacementLinear', 'IFC4X3', *args, **kwargs) + + +def IfcBSplineCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurve', 'IFC4X3', *args, **kwargs) + + +def IfcBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurveWithKnots', 'IFC4X3', *args, **kwargs) + + +def IfcBSplineSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurface', 'IFC4X3', *args, **kwargs) + + +def IfcBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurfaceWithKnots', 'IFC4X3', *args, **kwargs) + + +def IfcBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcBeam', 'IFC4X3', *args, **kwargs) + + +def IfcBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamType', 'IFC4X3', *args, **kwargs) + + +def IfcBearing(*args, **kwargs): return ifcopenshell.create_entity('IfcBearing', 'IFC4X3', *args, **kwargs) + + +def IfcBearingType(*args, **kwargs): return ifcopenshell.create_entity('IfcBearingType', 'IFC4X3', *args, **kwargs) + + +def IfcBlobTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcBlobTexture', 'IFC4X3', *args, **kwargs) + + +def IfcBlock(*args, **kwargs): return ifcopenshell.create_entity('IfcBlock', 'IFC4X3', *args, **kwargs) + + +def IfcBoiler(*args, **kwargs): return ifcopenshell.create_entity('IfcBoiler', 'IFC4X3', *args, **kwargs) + + +def IfcBoilerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBoilerType', 'IFC4X3', *args, **kwargs) + + +def IfcBooleanClippingResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanClippingResult', 'IFC4X3', *args, **kwargs) + + +def IfcBooleanResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanResult', 'IFC4X3', *args, **kwargs) + + +def IfcBorehole(*args, **kwargs): return ifcopenshell.create_entity('IfcBorehole', 'IFC4X3', *args, **kwargs) + + +def IfcBoundaryCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCondition', 'IFC4X3', *args, **kwargs) + + +def IfcBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCurve', 'IFC4X3', *args, **kwargs) + + +def IfcBoundaryEdgeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryEdgeCondition', 'IFC4X3', *args, **kwargs) + + +def IfcBoundaryFaceCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryFaceCondition', 'IFC4X3', *args, **kwargs) + + +def IfcBoundaryNodeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeCondition', 'IFC4X3', *args, **kwargs) + + +def IfcBoundaryNodeConditionWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeConditionWarping', 'IFC4X3', *args, **kwargs) + + +def IfcBoundedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedCurve', 'IFC4X3', *args, **kwargs) + + +def IfcBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedSurface', 'IFC4X3', *args, **kwargs) + + +def IfcBoundingBox(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundingBox', 'IFC4X3', *args, **kwargs) + + +def IfcBoxedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcBoxedHalfSpace', 'IFC4X3', *args, **kwargs) + + +def IfcBridge(*args, **kwargs): return ifcopenshell.create_entity('IfcBridge', 'IFC4X3', *args, **kwargs) + + +def IfcBridgePart(*args, **kwargs): return ifcopenshell.create_entity('IfcBridgePart', 'IFC4X3', *args, **kwargs) + + +def IfcBuilding(*args, **kwargs): return ifcopenshell.create_entity('IfcBuilding', 'IFC4X3', *args, **kwargs) + + +def IfcBuildingElementPart(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPart', 'IFC4X3', *args, **kwargs) + + +def IfcBuildingElementPartType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPartType', 'IFC4X3', *args, **kwargs) + + +def IfcBuildingElementProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxy', 'IFC4X3', *args, **kwargs) + + +def IfcBuildingElementProxyType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxyType', 'IFC4X3', *args, **kwargs) + + +def IfcBuildingStorey(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingStorey', 'IFC4X3', *args, **kwargs) + + +def IfcBuildingSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingSystem', 'IFC4X3', *args, **kwargs) + + +def IfcBuiltElement(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltElement', 'IFC4X3', *args, **kwargs) + + +def IfcBuiltElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltElementType', 'IFC4X3', *args, **kwargs) + + +def IfcBuiltSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltSystem', 'IFC4X3', *args, **kwargs) + + +def IfcBurner(*args, **kwargs): return ifcopenshell.create_entity('IfcBurner', 'IFC4X3', *args, **kwargs) + + +def IfcBurnerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBurnerType', 'IFC4X3', *args, **kwargs) + + +def IfcCShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCShapeProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcCableCarrierFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFitting', 'IFC4X3', *args, **kwargs) + + +def IfcCableCarrierFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFittingType', 'IFC4X3', *args, **kwargs) + + +def IfcCableCarrierSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegment', 'IFC4X3', *args, **kwargs) + + +def IfcCableCarrierSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegmentType', 'IFC4X3', *args, **kwargs) + + +def IfcCableFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFitting', 'IFC4X3', *args, **kwargs) + + +def IfcCableFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFittingType', 'IFC4X3', *args, **kwargs) + + +def IfcCableSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegment', 'IFC4X3', *args, **kwargs) + + +def IfcCableSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegmentType', 'IFC4X3', *args, **kwargs) + + +def IfcCaissonFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundation', 'IFC4X3', *args, **kwargs) + + +def IfcCaissonFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundationType', 'IFC4X3', *args, **kwargs) + + +def IfcCartesianPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPoint', 'IFC4X3', *args, **kwargs) + + +def IfcCartesianPointList(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList', 'IFC4X3', *args, **kwargs) + + +def IfcCartesianPointList2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList2D', 'IFC4X3', *args, **kwargs) + + +def IfcCartesianPointList3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList3D', 'IFC4X3', *args, **kwargs) + + +def IfcCartesianTransformationOperator(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator', 'IFC4X3', *args, **kwargs) + + +def IfcCartesianTransformationOperator2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2D', 'IFC4X3', *args, **kwargs) + + +def IfcCartesianTransformationOperator2DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2DnonUniform', 'IFC4X3', *args, **kwargs) + + +def IfcCartesianTransformationOperator3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3D', 'IFC4X3', *args, **kwargs) + + +def IfcCartesianTransformationOperator3DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3DnonUniform', 'IFC4X3', *args, **kwargs) + + +def IfcCenterLineProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCenterLineProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcChiller(*args, **kwargs): return ifcopenshell.create_entity('IfcChiller', 'IFC4X3', *args, **kwargs) + + +def IfcChillerType(*args, **kwargs): return ifcopenshell.create_entity('IfcChillerType', 'IFC4X3', *args, **kwargs) + + +def IfcChimney(*args, **kwargs): return ifcopenshell.create_entity('IfcChimney', 'IFC4X3', *args, **kwargs) + + +def IfcChimneyType(*args, **kwargs): return ifcopenshell.create_entity('IfcChimneyType', 'IFC4X3', *args, **kwargs) + + +def IfcCircle(*args, **kwargs): return ifcopenshell.create_entity('IfcCircle', 'IFC4X3', *args, **kwargs) + + +def IfcCircleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleHollowProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcCircleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcCivilElement(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElement', 'IFC4X3', *args, **kwargs) + + +def IfcCivilElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElementType', 'IFC4X3', *args, **kwargs) + + +def IfcClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcClassification', 'IFC4X3', *args, **kwargs) + + +def IfcClassificationReference(*args, **kwargs): return ifcopenshell.create_entity('IfcClassificationReference', 'IFC4X3', *args, **kwargs) + + +def IfcClosedShell(*args, **kwargs): return ifcopenshell.create_entity('IfcClosedShell', 'IFC4X3', *args, **kwargs) + + +def IfcClothoid(*args, **kwargs): return ifcopenshell.create_entity('IfcClothoid', 'IFC4X3', *args, **kwargs) + + +def IfcCoil(*args, **kwargs): return ifcopenshell.create_entity('IfcCoil', 'IFC4X3', *args, **kwargs) + + +def IfcCoilType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoilType', 'IFC4X3', *args, **kwargs) + + +def IfcColourRgb(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgb', 'IFC4X3', *args, **kwargs) + + +def IfcColourRgbList(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgbList', 'IFC4X3', *args, **kwargs) + + +def IfcColourSpecification(*args, **kwargs): return ifcopenshell.create_entity('IfcColourSpecification', 'IFC4X3', *args, **kwargs) + + +def IfcColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcColumn', 'IFC4X3', *args, **kwargs) + + +def IfcColumnType(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnType', 'IFC4X3', *args, **kwargs) + + +def IfcCommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsAppliance', 'IFC4X3', *args, **kwargs) + + +def IfcCommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsApplianceType', 'IFC4X3', *args, **kwargs) + + +def IfcComplexProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexProperty', 'IFC4X3', *args, **kwargs) + + +def IfcComplexPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexPropertyTemplate', 'IFC4X3', *args, **kwargs) + + +def IfcCompositeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurve', 'IFC4X3', *args, **kwargs) + + +def IfcCompositeCurveOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveOnSurface', 'IFC4X3', *args, **kwargs) + + +def IfcCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveSegment', 'IFC4X3', *args, **kwargs) + + +def IfcCompositeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcCompressor(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressor', 'IFC4X3', *args, **kwargs) + + +def IfcCompressorType(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressorType', 'IFC4X3', *args, **kwargs) + + +def IfcCondenser(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenser', 'IFC4X3', *args, **kwargs) + + +def IfcCondenserType(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenserType', 'IFC4X3', *args, **kwargs) + + +def IfcConic(*args, **kwargs): return ifcopenshell.create_entity('IfcConic', 'IFC4X3', *args, **kwargs) + + +def IfcConnectedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectedFaceSet', 'IFC4X3', *args, **kwargs) + + +def IfcConnectionCurveGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionCurveGeometry', 'IFC4X3', *args, **kwargs) + + +def IfcConnectionGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionGeometry', 'IFC4X3', *args, **kwargs) + + +def IfcConnectionPointEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointEccentricity', 'IFC4X3', *args, **kwargs) + + +def IfcConnectionPointGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointGeometry', 'IFC4X3', *args, **kwargs) + + +def IfcConnectionSurfaceGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionSurfaceGeometry', 'IFC4X3', *args, **kwargs) + + +def IfcConnectionVolumeGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionVolumeGeometry', 'IFC4X3', *args, **kwargs) + + +def IfcConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcConstraint', 'IFC4X3', *args, **kwargs) + + +def IfcConstructionEquipmentResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResource', 'IFC4X3', *args, **kwargs) + + +def IfcConstructionEquipmentResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResourceType', 'IFC4X3', *args, **kwargs) + + +def IfcConstructionMaterialResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResource', 'IFC4X3', *args, **kwargs) + + +def IfcConstructionMaterialResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResourceType', 'IFC4X3', *args, **kwargs) + + +def IfcConstructionProductResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResource', 'IFC4X3', *args, **kwargs) + + +def IfcConstructionProductResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResourceType', 'IFC4X3', *args, **kwargs) + + +def IfcConstructionResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResource', 'IFC4X3', *args, **kwargs) + + +def IfcConstructionResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResourceType', 'IFC4X3', *args, **kwargs) + + +def IfcContext(*args, **kwargs): return ifcopenshell.create_entity('IfcContext', 'IFC4X3', *args, **kwargs) + + +def IfcContextDependentUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcContextDependentUnit', 'IFC4X3', *args, **kwargs) + + +def IfcControl(*args, **kwargs): return ifcopenshell.create_entity('IfcControl', 'IFC4X3', *args, **kwargs) + + +def IfcController(*args, **kwargs): return ifcopenshell.create_entity('IfcController', 'IFC4X3', *args, **kwargs) + + +def IfcControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcControllerType', 'IFC4X3', *args, **kwargs) + + +def IfcConversionBasedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnit', 'IFC4X3', *args, **kwargs) + + +def IfcConversionBasedUnitWithOffset(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnitWithOffset', 'IFC4X3', *args, **kwargs) + + +def IfcConveyorSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcConveyorSegment', 'IFC4X3', *args, **kwargs) + + +def IfcConveyorSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcConveyorSegmentType', 'IFC4X3', *args, **kwargs) + + +def IfcCooledBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeam', 'IFC4X3', *args, **kwargs) + + +def IfcCooledBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeamType', 'IFC4X3', *args, **kwargs) + + +def IfcCoolingTower(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTower', 'IFC4X3', *args, **kwargs) + + +def IfcCoolingTowerType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTowerType', 'IFC4X3', *args, **kwargs) + + +def IfcCoordinateOperation(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateOperation', 'IFC4X3', *args, **kwargs) + + +def IfcCoordinateReferenceSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateReferenceSystem', 'IFC4X3', *args, **kwargs) + + +def IfcCosineSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcCosineSpiral', 'IFC4X3', *args, **kwargs) + + +def IfcCostItem(*args, **kwargs): return ifcopenshell.create_entity('IfcCostItem', 'IFC4X3', *args, **kwargs) + + +def IfcCostSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcCostSchedule', 'IFC4X3', *args, **kwargs) + + +def IfcCostValue(*args, **kwargs): return ifcopenshell.create_entity('IfcCostValue', 'IFC4X3', *args, **kwargs) + + +def IfcCourse(*args, **kwargs): return ifcopenshell.create_entity('IfcCourse', 'IFC4X3', *args, **kwargs) + + +def IfcCourseType(*args, **kwargs): return ifcopenshell.create_entity('IfcCourseType', 'IFC4X3', *args, **kwargs) + + +def IfcCovering(*args, **kwargs): return ifcopenshell.create_entity('IfcCovering', 'IFC4X3', *args, **kwargs) + + +def IfcCoveringType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoveringType', 'IFC4X3', *args, **kwargs) + + +def IfcCrewResource(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResource', 'IFC4X3', *args, **kwargs) + + +def IfcCrewResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResourceType', 'IFC4X3', *args, **kwargs) + + +def IfcCsgPrimitive3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgPrimitive3D', 'IFC4X3', *args, **kwargs) + + +def IfcCsgSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgSolid', 'IFC4X3', *args, **kwargs) + + +def IfcCurrencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcCurrencyRelationship', 'IFC4X3', *args, **kwargs) + + +def IfcCurtainWall(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWall', 'IFC4X3', *args, **kwargs) + + +def IfcCurtainWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWallType', 'IFC4X3', *args, **kwargs) + + +def IfcCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCurve', 'IFC4X3', *args, **kwargs) + + +def IfcCurveBoundedPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedPlane', 'IFC4X3', *args, **kwargs) + + +def IfcCurveBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedSurface', 'IFC4X3', *args, **kwargs) + + +def IfcCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveSegment', 'IFC4X3', *args, **kwargs) + + +def IfcCurveStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyle', 'IFC4X3', *args, **kwargs) + + +def IfcCurveStyleFont(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFont', 'IFC4X3', *args, **kwargs) + + +def IfcCurveStyleFontAndScaling(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontAndScaling', 'IFC4X3', *args, **kwargs) + + +def IfcCurveStyleFontPattern(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontPattern', 'IFC4X3', *args, **kwargs) + + +def IfcCylindricalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCylindricalSurface', 'IFC4X3', *args, **kwargs) + + +def IfcDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcDamper', 'IFC4X3', *args, **kwargs) + + +def IfcDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcDamperType', 'IFC4X3', *args, **kwargs) + + +def IfcDeepFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundation', 'IFC4X3', *args, **kwargs) + + +def IfcDeepFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundationType', 'IFC4X3', *args, **kwargs) + + +def IfcDerivedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcDerivedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnit', 'IFC4X3', *args, **kwargs) + + +def IfcDerivedUnitElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnitElement', 'IFC4X3', *args, **kwargs) + + +def IfcDimensionalExponents(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionalExponents', 'IFC4X3', *args, **kwargs) + + +def IfcDirection(*args, **kwargs): return ifcopenshell.create_entity('IfcDirection', 'IFC4X3', *args, **kwargs) + + +def IfcDirectrixCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcDirectrixCurveSweptAreaSolid', 'IFC4X3', *args, **kwargs) + + +def IfcDirectrixDerivedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcDirectrixDerivedReferenceSweptAreaSolid', 'IFC4X3', *args, **kwargs) + + +def IfcDiscreteAccessory(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessory', 'IFC4X3', *args, **kwargs) + + +def IfcDiscreteAccessoryType(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessoryType', 'IFC4X3', *args, **kwargs) + + +def IfcDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionBoard', 'IFC4X3', *args, **kwargs) + + +def IfcDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionBoardType', 'IFC4X3', *args, **kwargs) + + +def IfcDistributionChamberElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElement', 'IFC4X3', *args, **kwargs) + + +def IfcDistributionChamberElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElementType', 'IFC4X3', *args, **kwargs) + + +def IfcDistributionCircuit(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionCircuit', 'IFC4X3', *args, **kwargs) + + +def IfcDistributionControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElement', 'IFC4X3', *args, **kwargs) + + +def IfcDistributionControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElementType', 'IFC4X3', *args, **kwargs) + + +def IfcDistributionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElement', 'IFC4X3', *args, **kwargs) + + +def IfcDistributionElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElementType', 'IFC4X3', *args, **kwargs) + + +def IfcDistributionFlowElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElement', 'IFC4X3', *args, **kwargs) + + +def IfcDistributionFlowElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElementType', 'IFC4X3', *args, **kwargs) + + +def IfcDistributionPort(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionPort', 'IFC4X3', *args, **kwargs) + + +def IfcDistributionSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionSystem', 'IFC4X3', *args, **kwargs) + + +def IfcDocumentInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformation', 'IFC4X3', *args, **kwargs) + + +def IfcDocumentInformationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformationRelationship', 'IFC4X3', *args, **kwargs) + + +def IfcDocumentReference(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentReference', 'IFC4X3', *args, **kwargs) + + +def IfcDoor(*args, **kwargs): return ifcopenshell.create_entity('IfcDoor', 'IFC4X3', *args, **kwargs) + + +def IfcDoorLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorLiningProperties', 'IFC4X3', *args, **kwargs) + + +def IfcDoorPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorPanelProperties', 'IFC4X3', *args, **kwargs) + + +def IfcDoorType(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorType', 'IFC4X3', *args, **kwargs) + + +def IfcDraughtingPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedColour', 'IFC4X3', *args, **kwargs) + + +def IfcDraughtingPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedCurveFont', 'IFC4X3', *args, **kwargs) + + +def IfcDuctFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFitting', 'IFC4X3', *args, **kwargs) + + +def IfcDuctFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFittingType', 'IFC4X3', *args, **kwargs) + + +def IfcDuctSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegment', 'IFC4X3', *args, **kwargs) + + +def IfcDuctSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegmentType', 'IFC4X3', *args, **kwargs) + + +def IfcDuctSilencer(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencer', 'IFC4X3', *args, **kwargs) + + +def IfcDuctSilencerType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencerType', 'IFC4X3', *args, **kwargs) + + +def IfcEarthworksCut(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksCut', 'IFC4X3', *args, **kwargs) + + +def IfcEarthworksElement(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksElement', 'IFC4X3', *args, **kwargs) + + +def IfcEarthworksFill(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksFill', 'IFC4X3', *args, **kwargs) + + +def IfcEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcEdge', 'IFC4X3', *args, **kwargs) + + +def IfcEdgeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeCurve', 'IFC4X3', *args, **kwargs) + + +def IfcEdgeLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeLoop', 'IFC4X3', *args, **kwargs) + + +def IfcElectricAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricAppliance', 'IFC4X3', *args, **kwargs) + + +def IfcElectricApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricApplianceType', 'IFC4X3', *args, **kwargs) + + +def IfcElectricDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoard', 'IFC4X3', *args, **kwargs) + + +def IfcElectricDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoardType', 'IFC4X3', *args, **kwargs) + + +def IfcElectricFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDevice', 'IFC4X3', *args, **kwargs) + + +def IfcElectricFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDeviceType', 'IFC4X3', *args, **kwargs) + + +def IfcElectricFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowTreatmentDevice', 'IFC4X3', *args, **kwargs) + + +def IfcElectricFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowTreatmentDeviceType', 'IFC4X3', *args, **kwargs) + + +def IfcElectricGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGenerator', 'IFC4X3', *args, **kwargs) + + +def IfcElectricGeneratorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGeneratorType', 'IFC4X3', *args, **kwargs) + + +def IfcElectricMotor(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotor', 'IFC4X3', *args, **kwargs) + + +def IfcElectricMotorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotorType', 'IFC4X3', *args, **kwargs) + + +def IfcElectricTimeControl(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControl', 'IFC4X3', *args, **kwargs) + + +def IfcElectricTimeControlType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControlType', 'IFC4X3', *args, **kwargs) + + +def IfcElement(*args, **kwargs): return ifcopenshell.create_entity('IfcElement', 'IFC4X3', *args, **kwargs) + + +def IfcElementAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssembly', 'IFC4X3', *args, **kwargs) + + +def IfcElementAssemblyType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssemblyType', 'IFC4X3', *args, **kwargs) + + +def IfcElementComponent(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponent', 'IFC4X3', *args, **kwargs) + + +def IfcElementComponentType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponentType', 'IFC4X3', *args, **kwargs) + + +def IfcElementQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcElementQuantity', 'IFC4X3', *args, **kwargs) + + +def IfcElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementType', 'IFC4X3', *args, **kwargs) + + +def IfcElementarySurface(*args, **kwargs): return ifcopenshell.create_entity('IfcElementarySurface', 'IFC4X3', *args, **kwargs) + + +def IfcEllipse(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipse', 'IFC4X3', *args, **kwargs) + + +def IfcEllipseProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipseProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcEnergyConversionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDevice', 'IFC4X3', *args, **kwargs) + + +def IfcEnergyConversionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDeviceType', 'IFC4X3', *args, **kwargs) + + +def IfcEngine(*args, **kwargs): return ifcopenshell.create_entity('IfcEngine', 'IFC4X3', *args, **kwargs) + + +def IfcEngineType(*args, **kwargs): return ifcopenshell.create_entity('IfcEngineType', 'IFC4X3', *args, **kwargs) + + +def IfcEvaporativeCooler(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCooler', 'IFC4X3', *args, **kwargs) + + +def IfcEvaporativeCoolerType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCoolerType', 'IFC4X3', *args, **kwargs) + + +def IfcEvaporator(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporator', 'IFC4X3', *args, **kwargs) + + +def IfcEvaporatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporatorType', 'IFC4X3', *args, **kwargs) + + +def IfcEvent(*args, **kwargs): return ifcopenshell.create_entity('IfcEvent', 'IFC4X3', *args, **kwargs) + + +def IfcEventTime(*args, **kwargs): return ifcopenshell.create_entity('IfcEventTime', 'IFC4X3', *args, **kwargs) + + +def IfcEventType(*args, **kwargs): return ifcopenshell.create_entity('IfcEventType', 'IFC4X3', *args, **kwargs) + + +def IfcExtendedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcExtendedProperties', 'IFC4X3', *args, **kwargs) + + +def IfcExternalInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalInformation', 'IFC4X3', *args, **kwargs) + + +def IfcExternalReference(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReference', 'IFC4X3', *args, **kwargs) + + +def IfcExternalReferenceRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReferenceRelationship', 'IFC4X3', *args, **kwargs) + + +def IfcExternalSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialElement', 'IFC4X3', *args, **kwargs) + + +def IfcExternalSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialStructureElement', 'IFC4X3', *args, **kwargs) + + +def IfcExternallyDefinedHatchStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedHatchStyle', 'IFC4X3', *args, **kwargs) + + +def IfcExternallyDefinedSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedSurfaceStyle', 'IFC4X3', *args, **kwargs) + + +def IfcExternallyDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedTextFont', 'IFC4X3', *args, **kwargs) + + +def IfcExtrudedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolid', 'IFC4X3', *args, **kwargs) + + +def IfcExtrudedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolidTapered', 'IFC4X3', *args, **kwargs) + + +def IfcFace(*args, **kwargs): return ifcopenshell.create_entity('IfcFace', 'IFC4X3', *args, **kwargs) + + +def IfcFaceBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBasedSurfaceModel', 'IFC4X3', *args, **kwargs) + + +def IfcFaceBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBound', 'IFC4X3', *args, **kwargs) + + +def IfcFaceOuterBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceOuterBound', 'IFC4X3', *args, **kwargs) + + +def IfcFaceSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceSurface', 'IFC4X3', *args, **kwargs) + + +def IfcFacetedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrep', 'IFC4X3', *args, **kwargs) + + +def IfcFacetedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrepWithVoids', 'IFC4X3', *args, **kwargs) + + +def IfcFacility(*args, **kwargs): return ifcopenshell.create_entity('IfcFacility', 'IFC4X3', *args, **kwargs) + + +def IfcFacilityPart(*args, **kwargs): return ifcopenshell.create_entity('IfcFacilityPart', 'IFC4X3', *args, **kwargs) + + +def IfcFacilityPartCommon(*args, **kwargs): return ifcopenshell.create_entity('IfcFacilityPartCommon', 'IFC4X3', *args, **kwargs) + + +def IfcFailureConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcFailureConnectionCondition', 'IFC4X3', *args, **kwargs) + + +def IfcFan(*args, **kwargs): return ifcopenshell.create_entity('IfcFan', 'IFC4X3', *args, **kwargs) + + +def IfcFanType(*args, **kwargs): return ifcopenshell.create_entity('IfcFanType', 'IFC4X3', *args, **kwargs) + + +def IfcFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcFastener', 'IFC4X3', *args, **kwargs) + + +def IfcFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFastenerType', 'IFC4X3', *args, **kwargs) + + +def IfcFeatureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElement', 'IFC4X3', *args, **kwargs) + + +def IfcFeatureElementAddition(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementAddition', 'IFC4X3', *args, **kwargs) + + +def IfcFeatureElementSubtraction(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementSubtraction', 'IFC4X3', *args, **kwargs) + + +def IfcFillAreaStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyle', 'IFC4X3', *args, **kwargs) + + +def IfcFillAreaStyleHatching(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleHatching', 'IFC4X3', *args, **kwargs) + + +def IfcFillAreaStyleTiles(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleTiles', 'IFC4X3', *args, **kwargs) + + +def IfcFilter(*args, **kwargs): return ifcopenshell.create_entity('IfcFilter', 'IFC4X3', *args, **kwargs) + + +def IfcFilterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFilterType', 'IFC4X3', *args, **kwargs) + + +def IfcFireSuppressionTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminal', 'IFC4X3', *args, **kwargs) + + +def IfcFireSuppressionTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminalType', 'IFC4X3', *args, **kwargs) + + +def IfcFixedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcFixedReferenceSweptAreaSolid', 'IFC4X3', *args, **kwargs) + + +def IfcFlowController(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowController', 'IFC4X3', *args, **kwargs) + + +def IfcFlowControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowControllerType', 'IFC4X3', *args, **kwargs) + + +def IfcFlowFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFitting', 'IFC4X3', *args, **kwargs) + + +def IfcFlowFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFittingType', 'IFC4X3', *args, **kwargs) + + +def IfcFlowInstrument(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrument', 'IFC4X3', *args, **kwargs) + + +def IfcFlowInstrumentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrumentType', 'IFC4X3', *args, **kwargs) + + +def IfcFlowMeter(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeter', 'IFC4X3', *args, **kwargs) + + +def IfcFlowMeterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeterType', 'IFC4X3', *args, **kwargs) + + +def IfcFlowMovingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDevice', 'IFC4X3', *args, **kwargs) + + +def IfcFlowMovingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDeviceType', 'IFC4X3', *args, **kwargs) + + +def IfcFlowSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegment', 'IFC4X3', *args, **kwargs) + + +def IfcFlowSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegmentType', 'IFC4X3', *args, **kwargs) + + +def IfcFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDevice', 'IFC4X3', *args, **kwargs) + + +def IfcFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDeviceType', 'IFC4X3', *args, **kwargs) + + +def IfcFlowTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminal', 'IFC4X3', *args, **kwargs) + + +def IfcFlowTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminalType', 'IFC4X3', *args, **kwargs) + + +def IfcFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDevice', 'IFC4X3', *args, **kwargs) + + +def IfcFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDeviceType', 'IFC4X3', *args, **kwargs) + + +def IfcFooting(*args, **kwargs): return ifcopenshell.create_entity('IfcFooting', 'IFC4X3', *args, **kwargs) + + +def IfcFootingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFootingType', 'IFC4X3', *args, **kwargs) + + +def IfcFurnishingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElement', 'IFC4X3', *args, **kwargs) + + +def IfcFurnishingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElementType', 'IFC4X3', *args, **kwargs) + + +def IfcFurniture(*args, **kwargs): return ifcopenshell.create_entity('IfcFurniture', 'IFC4X3', *args, **kwargs) + + +def IfcFurnitureType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnitureType', 'IFC4X3', *args, **kwargs) + + +def IfcGeographicElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElement', 'IFC4X3', *args, **kwargs) + + +def IfcGeographicElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElementType', 'IFC4X3', *args, **kwargs) + + +def IfcGeometricCurveSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricCurveSet', 'IFC4X3', *args, **kwargs) + + +def IfcGeometricRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationContext', 'IFC4X3', *args, **kwargs) + + +def IfcGeometricRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationItem', 'IFC4X3', *args, **kwargs) + + +def IfcGeometricRepresentationSubContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationSubContext', 'IFC4X3', *args, **kwargs) + + +def IfcGeometricSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricSet', 'IFC4X3', *args, **kwargs) + + +def IfcGeomodel(*args, **kwargs): return ifcopenshell.create_entity('IfcGeomodel', 'IFC4X3', *args, **kwargs) + + +def IfcGeoslice(*args, **kwargs): return ifcopenshell.create_entity('IfcGeoslice', 'IFC4X3', *args, **kwargs) + + +def IfcGeotechnicalAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalAssembly', 'IFC4X3', *args, **kwargs) + + +def IfcGeotechnicalElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalElement', 'IFC4X3', *args, **kwargs) + + +def IfcGeotechnicalStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalStratum', 'IFC4X3', *args, **kwargs) + + +def IfcGradientCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcGradientCurve', 'IFC4X3', *args, **kwargs) + + +def IfcGrid(*args, **kwargs): return ifcopenshell.create_entity('IfcGrid', 'IFC4X3', *args, **kwargs) + + +def IfcGridAxis(*args, **kwargs): return ifcopenshell.create_entity('IfcGridAxis', 'IFC4X3', *args, **kwargs) + + +def IfcGridPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcGridPlacement', 'IFC4X3', *args, **kwargs) + + +def IfcGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcGroup', 'IFC4X3', *args, **kwargs) + + +def IfcHalfSpaceSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcHalfSpaceSolid', 'IFC4X3', *args, **kwargs) + + +def IfcHeatExchanger(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchanger', 'IFC4X3', *args, **kwargs) + + +def IfcHeatExchangerType(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchangerType', 'IFC4X3', *args, **kwargs) + + +def IfcHumidifier(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifier', 'IFC4X3', *args, **kwargs) + + +def IfcHumidifierType(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifierType', 'IFC4X3', *args, **kwargs) + + +def IfcIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcIShapeProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcImageTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcImageTexture', 'IFC4X3', *args, **kwargs) + + +def IfcImpactProtectionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcImpactProtectionDevice', 'IFC4X3', *args, **kwargs) + + +def IfcImpactProtectionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcImpactProtectionDeviceType', 'IFC4X3', *args, **kwargs) + + +def IfcIndexedColourMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedColourMap', 'IFC4X3', *args, **kwargs) + + +def IfcIndexedPolyCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolyCurve', 'IFC4X3', *args, **kwargs) + + +def IfcIndexedPolygonalFace(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFace', 'IFC4X3', *args, **kwargs) + + +def IfcIndexedPolygonalFaceWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFaceWithVoids', 'IFC4X3', *args, **kwargs) + + +def IfcIndexedPolygonalTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalTextureMap', 'IFC4X3', *args, **kwargs) + + +def IfcIndexedTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTextureMap', 'IFC4X3', *args, **kwargs) + + +def IfcIndexedTriangleTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTriangleTextureMap', 'IFC4X3', *args, **kwargs) + + +def IfcInterceptor(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptor', 'IFC4X3', *args, **kwargs) + + +def IfcInterceptorType(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptorType', 'IFC4X3', *args, **kwargs) + + +def IfcIntersectionCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIntersectionCurve', 'IFC4X3', *args, **kwargs) + + +def IfcInventory(*args, **kwargs): return ifcopenshell.create_entity('IfcInventory', 'IFC4X3', *args, **kwargs) + + +def IfcIrregularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeries', 'IFC4X3', *args, **kwargs) + + +def IfcIrregularTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeriesValue', 'IFC4X3', *args, **kwargs) + + +def IfcJunctionBox(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBox', 'IFC4X3', *args, **kwargs) + + +def IfcJunctionBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBoxType', 'IFC4X3', *args, **kwargs) + + +def IfcKerb(*args, **kwargs): return ifcopenshell.create_entity('IfcKerb', 'IFC4X3', *args, **kwargs) + + +def IfcKerbType(*args, **kwargs): return ifcopenshell.create_entity('IfcKerbType', 'IFC4X3', *args, **kwargs) + + +def IfcLShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcLShapeProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcLaborResource(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResource', 'IFC4X3', *args, **kwargs) + + +def IfcLaborResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResourceType', 'IFC4X3', *args, **kwargs) + + +def IfcLagTime(*args, **kwargs): return ifcopenshell.create_entity('IfcLagTime', 'IFC4X3', *args, **kwargs) + + +def IfcLamp(*args, **kwargs): return ifcopenshell.create_entity('IfcLamp', 'IFC4X3', *args, **kwargs) + + +def IfcLampType(*args, **kwargs): return ifcopenshell.create_entity('IfcLampType', 'IFC4X3', *args, **kwargs) + + +def IfcLibraryInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryInformation', 'IFC4X3', *args, **kwargs) + + +def IfcLibraryReference(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryReference', 'IFC4X3', *args, **kwargs) + + +def IfcLightDistributionData(*args, **kwargs): return ifcopenshell.create_entity('IfcLightDistributionData', 'IFC4X3', *args, **kwargs) + + +def IfcLightFixture(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixture', 'IFC4X3', *args, **kwargs) + + +def IfcLightFixtureType(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixtureType', 'IFC4X3', *args, **kwargs) + + +def IfcLightIntensityDistribution(*args, **kwargs): return ifcopenshell.create_entity('IfcLightIntensityDistribution', 'IFC4X3', *args, **kwargs) + + +def IfcLightSource(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSource', 'IFC4X3', *args, **kwargs) + + +def IfcLightSourceAmbient(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceAmbient', 'IFC4X3', *args, **kwargs) + + +def IfcLightSourceDirectional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceDirectional', 'IFC4X3', *args, **kwargs) + + +def IfcLightSourceGoniometric(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceGoniometric', 'IFC4X3', *args, **kwargs) + + +def IfcLightSourcePositional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourcePositional', 'IFC4X3', *args, **kwargs) + + +def IfcLightSourceSpot(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceSpot', 'IFC4X3', *args, **kwargs) + + +def IfcLine(*args, **kwargs): return ifcopenshell.create_entity('IfcLine', 'IFC4X3', *args, **kwargs) + + +def IfcLinearElement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearElement', 'IFC4X3', *args, **kwargs) + + +def IfcLinearPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPlacement', 'IFC4X3', *args, **kwargs) + + +def IfcLinearPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPositioningElement', 'IFC4X3', *args, **kwargs) + + +def IfcLiquidTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcLiquidTerminal', 'IFC4X3', *args, **kwargs) + + +def IfcLiquidTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcLiquidTerminalType', 'IFC4X3', *args, **kwargs) + + +def IfcLocalPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLocalPlacement', 'IFC4X3', *args, **kwargs) + + +def IfcLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcLoop', 'IFC4X3', *args, **kwargs) + + +def IfcManifoldSolidBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcManifoldSolidBrep', 'IFC4X3', *args, **kwargs) + + +def IfcMapConversion(*args, **kwargs): return ifcopenshell.create_entity('IfcMapConversion', 'IFC4X3', *args, **kwargs) + + +def IfcMappedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcMappedItem', 'IFC4X3', *args, **kwargs) + + +def IfcMarineFacility(*args, **kwargs): return ifcopenshell.create_entity('IfcMarineFacility', 'IFC4X3', *args, **kwargs) + + +def IfcMarinePart(*args, **kwargs): return ifcopenshell.create_entity('IfcMarinePart', 'IFC4X3', *args, **kwargs) + + +def IfcMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterial', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialClassificationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialClassificationRelationship', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialConstituent(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituent', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialConstituentSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituentSet', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinition', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialDefinitionRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinitionRepresentation', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialLayer(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayer', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialLayerSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSet', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialLayerSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSetUsage', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialLayerWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerWithOffsets', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialList(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialList', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialProfile(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfile', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialProfileSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSet', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialProfileSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsage', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialProfileSetUsageTapering(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsageTapering', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialProfileWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileWithOffsets', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProperties', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialRelationship', 'IFC4X3', *args, **kwargs) + + +def IfcMaterialUsageDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialUsageDefinition', 'IFC4X3', *args, **kwargs) + + +def IfcMeasureWithUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMeasureWithUnit', 'IFC4X3', *args, **kwargs) + + +def IfcMechanicalFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastener', 'IFC4X3', *args, **kwargs) + + +def IfcMechanicalFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastenerType', 'IFC4X3', *args, **kwargs) + + +def IfcMedicalDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDevice', 'IFC4X3', *args, **kwargs) + + +def IfcMedicalDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDeviceType', 'IFC4X3', *args, **kwargs) + + +def IfcMember(*args, **kwargs): return ifcopenshell.create_entity('IfcMember', 'IFC4X3', *args, **kwargs) + + +def IfcMemberType(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberType', 'IFC4X3', *args, **kwargs) + + +def IfcMetric(*args, **kwargs): return ifcopenshell.create_entity('IfcMetric', 'IFC4X3', *args, **kwargs) + + +def IfcMirroredProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcMirroredProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcMobileTelecommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcMobileTelecommunicationsAppliance', 'IFC4X3', *args, **kwargs) + + +def IfcMobileTelecommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMobileTelecommunicationsApplianceType', 'IFC4X3', *args, **kwargs) + + +def IfcMonetaryUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMonetaryUnit', 'IFC4X3', *args, **kwargs) + + +def IfcMooringDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMooringDevice', 'IFC4X3', *args, **kwargs) + + +def IfcMooringDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMooringDeviceType', 'IFC4X3', *args, **kwargs) + + +def IfcMotorConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnection', 'IFC4X3', *args, **kwargs) + + +def IfcMotorConnectionType(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnectionType', 'IFC4X3', *args, **kwargs) + + +def IfcNamedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcNamedUnit', 'IFC4X3', *args, **kwargs) + + +def IfcNavigationElement(*args, **kwargs): return ifcopenshell.create_entity('IfcNavigationElement', 'IFC4X3', *args, **kwargs) + + +def IfcNavigationElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcNavigationElementType', 'IFC4X3', *args, **kwargs) + + +def IfcObject(*args, **kwargs): return ifcopenshell.create_entity('IfcObject', 'IFC4X3', *args, **kwargs) + + +def IfcObjectDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectDefinition', 'IFC4X3', *args, **kwargs) + + +def IfcObjectPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectPlacement', 'IFC4X3', *args, **kwargs) + + +def IfcObjective(*args, **kwargs): return ifcopenshell.create_entity('IfcObjective', 'IFC4X3', *args, **kwargs) + + +def IfcOccupant(*args, **kwargs): return ifcopenshell.create_entity('IfcOccupant', 'IFC4X3', *args, **kwargs) + + +def IfcOffsetCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve', 'IFC4X3', *args, **kwargs) + + +def IfcOffsetCurve2D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve2D', 'IFC4X3', *args, **kwargs) + + +def IfcOffsetCurve3D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve3D', 'IFC4X3', *args, **kwargs) + + +def IfcOffsetCurveByDistances(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurveByDistances', 'IFC4X3', *args, **kwargs) + + +def IfcOpenCrossProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenCrossProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcOpenShell(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenShell', 'IFC4X3', *args, **kwargs) + + +def IfcOpeningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningElement', 'IFC4X3', *args, **kwargs) + + +def IfcOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganization', 'IFC4X3', *args, **kwargs) + + +def IfcOrganizationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganizationRelationship', 'IFC4X3', *args, **kwargs) + + +def IfcOrientedEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcOrientedEdge', 'IFC4X3', *args, **kwargs) + + +def IfcOuterBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOuterBoundaryCurve', 'IFC4X3', *args, **kwargs) + + +def IfcOutlet(*args, **kwargs): return ifcopenshell.create_entity('IfcOutlet', 'IFC4X3', *args, **kwargs) + + +def IfcOutletType(*args, **kwargs): return ifcopenshell.create_entity('IfcOutletType', 'IFC4X3', *args, **kwargs) + + +def IfcOwnerHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcOwnerHistory', 'IFC4X3', *args, **kwargs) + + +def IfcParameterizedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcParameterizedProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcPath(*args, **kwargs): return ifcopenshell.create_entity('IfcPath', 'IFC4X3', *args, **kwargs) + + +def IfcPavement(*args, **kwargs): return ifcopenshell.create_entity('IfcPavement', 'IFC4X3', *args, **kwargs) + + +def IfcPavementType(*args, **kwargs): return ifcopenshell.create_entity('IfcPavementType', 'IFC4X3', *args, **kwargs) + + +def IfcPcurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPcurve', 'IFC4X3', *args, **kwargs) + + +def IfcPerformanceHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcPerformanceHistory', 'IFC4X3', *args, **kwargs) + + +def IfcPermeableCoveringProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPermeableCoveringProperties', 'IFC4X3', *args, **kwargs) + + +def IfcPermit(*args, **kwargs): return ifcopenshell.create_entity('IfcPermit', 'IFC4X3', *args, **kwargs) + + +def IfcPerson(*args, **kwargs): return ifcopenshell.create_entity('IfcPerson', 'IFC4X3', *args, **kwargs) + + +def IfcPersonAndOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcPersonAndOrganization', 'IFC4X3', *args, **kwargs) + + +def IfcPhysicalComplexQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalComplexQuantity', 'IFC4X3', *args, **kwargs) + + +def IfcPhysicalQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalQuantity', 'IFC4X3', *args, **kwargs) + + +def IfcPhysicalSimpleQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalSimpleQuantity', 'IFC4X3', *args, **kwargs) + + +def IfcPile(*args, **kwargs): return ifcopenshell.create_entity('IfcPile', 'IFC4X3', *args, **kwargs) + + +def IfcPileType(*args, **kwargs): return ifcopenshell.create_entity('IfcPileType', 'IFC4X3', *args, **kwargs) + + +def IfcPipeFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFitting', 'IFC4X3', *args, **kwargs) + + +def IfcPipeFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFittingType', 'IFC4X3', *args, **kwargs) + + +def IfcPipeSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegment', 'IFC4X3', *args, **kwargs) + + +def IfcPipeSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegmentType', 'IFC4X3', *args, **kwargs) + + +def IfcPixelTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcPixelTexture', 'IFC4X3', *args, **kwargs) + + +def IfcPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcPlacement', 'IFC4X3', *args, **kwargs) + + +def IfcPlanarBox(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarBox', 'IFC4X3', *args, **kwargs) + + +def IfcPlanarExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarExtent', 'IFC4X3', *args, **kwargs) + + +def IfcPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcPlane', 'IFC4X3', *args, **kwargs) + + +def IfcPlate(*args, **kwargs): return ifcopenshell.create_entity('IfcPlate', 'IFC4X3', *args, **kwargs) + + +def IfcPlateType(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateType', 'IFC4X3', *args, **kwargs) + + +def IfcPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcPoint', 'IFC4X3', *args, **kwargs) + + +def IfcPointByDistanceExpression(*args, **kwargs): return ifcopenshell.create_entity('IfcPointByDistanceExpression', 'IFC4X3', *args, **kwargs) + + +def IfcPointOnCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnCurve', 'IFC4X3', *args, **kwargs) + + +def IfcPointOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnSurface', 'IFC4X3', *args, **kwargs) + + +def IfcPolyLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyLoop', 'IFC4X3', *args, **kwargs) + + +def IfcPolygonalBoundedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalBoundedHalfSpace', 'IFC4X3', *args, **kwargs) + + +def IfcPolygonalFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalFaceSet', 'IFC4X3', *args, **kwargs) + + +def IfcPolyline(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyline', 'IFC4X3', *args, **kwargs) + + +def IfcPolynomialCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPolynomialCurve', 'IFC4X3', *args, **kwargs) + + +def IfcPort(*args, **kwargs): return ifcopenshell.create_entity('IfcPort', 'IFC4X3', *args, **kwargs) + + +def IfcPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcPositioningElement', 'IFC4X3', *args, **kwargs) + + +def IfcPostalAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcPostalAddress', 'IFC4X3', *args, **kwargs) + + +def IfcPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedColour', 'IFC4X3', *args, **kwargs) + + +def IfcPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedCurveFont', 'IFC4X3', *args, **kwargs) + + +def IfcPreDefinedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedItem', 'IFC4X3', *args, **kwargs) + + +def IfcPreDefinedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedProperties', 'IFC4X3', *args, **kwargs) + + +def IfcPreDefinedPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedPropertySet', 'IFC4X3', *args, **kwargs) + + +def IfcPreDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedTextFont', 'IFC4X3', *args, **kwargs) + + +def IfcPresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationItem', 'IFC4X3', *args, **kwargs) + + +def IfcPresentationLayerAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerAssignment', 'IFC4X3', *args, **kwargs) + + +def IfcPresentationLayerWithStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerWithStyle', 'IFC4X3', *args, **kwargs) + + +def IfcPresentationStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyle', 'IFC4X3', *args, **kwargs) + + +def IfcProcedure(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedure', 'IFC4X3', *args, **kwargs) + + +def IfcProcedureType(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedureType', 'IFC4X3', *args, **kwargs) + + +def IfcProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcProcess', 'IFC4X3', *args, **kwargs) + + +def IfcProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcProduct', 'IFC4X3', *args, **kwargs) + + +def IfcProductDefinitionShape(*args, **kwargs): return ifcopenshell.create_entity('IfcProductDefinitionShape', 'IFC4X3', *args, **kwargs) + + +def IfcProductRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcProductRepresentation', 'IFC4X3', *args, **kwargs) + + +def IfcProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileProperties', 'IFC4X3', *args, **kwargs) + + +def IfcProject(*args, **kwargs): return ifcopenshell.create_entity('IfcProject', 'IFC4X3', *args, **kwargs) + + +def IfcProjectLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectLibrary', 'IFC4X3', *args, **kwargs) + + +def IfcProjectOrder(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectOrder', 'IFC4X3', *args, **kwargs) + + +def IfcProjectedCRS(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectedCRS', 'IFC4X3', *args, **kwargs) + + +def IfcProjectionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectionElement', 'IFC4X3', *args, **kwargs) + + +def IfcProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcProperty', 'IFC4X3', *args, **kwargs) + + +def IfcPropertyAbstraction(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyAbstraction', 'IFC4X3', *args, **kwargs) + + +def IfcPropertyBoundedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyBoundedValue', 'IFC4X3', *args, **kwargs) + + +def IfcPropertyDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDefinition', 'IFC4X3', *args, **kwargs) + + +def IfcPropertyDependencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDependencyRelationship', 'IFC4X3', *args, **kwargs) + + +def IfcPropertyEnumeratedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeratedValue', 'IFC4X3', *args, **kwargs) + + +def IfcPropertyEnumeration(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeration', 'IFC4X3', *args, **kwargs) + + +def IfcPropertyListValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyListValue', 'IFC4X3', *args, **kwargs) + + +def IfcPropertyReferenceValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyReferenceValue', 'IFC4X3', *args, **kwargs) + + +def IfcPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySet', 'IFC4X3', *args, **kwargs) + + +def IfcPropertySetDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetDefinition', 'IFC4X3', *args, **kwargs) + + +def IfcPropertySetTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetTemplate', 'IFC4X3', *args, **kwargs) + + +def IfcPropertySingleValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySingleValue', 'IFC4X3', *args, **kwargs) + + +def IfcPropertyTableValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTableValue', 'IFC4X3', *args, **kwargs) + + +def IfcPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplate', 'IFC4X3', *args, **kwargs) + + +def IfcPropertyTemplateDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplateDefinition', 'IFC4X3', *args, **kwargs) + + +def IfcProtectiveDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDevice', 'IFC4X3', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnit', 'IFC4X3', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnitType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnitType', 'IFC4X3', *args, **kwargs) + + +def IfcProtectiveDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceType', 'IFC4X3', *args, **kwargs) + + +def IfcPump(*args, **kwargs): return ifcopenshell.create_entity('IfcPump', 'IFC4X3', *args, **kwargs) + + +def IfcPumpType(*args, **kwargs): return ifcopenshell.create_entity('IfcPumpType', 'IFC4X3', *args, **kwargs) + + +def IfcQuantityArea(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityArea', 'IFC4X3', *args, **kwargs) + + +def IfcQuantityCount(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityCount', 'IFC4X3', *args, **kwargs) + + +def IfcQuantityLength(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityLength', 'IFC4X3', *args, **kwargs) + + +def IfcQuantityNumber(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityNumber', 'IFC4X3', *args, **kwargs) + + +def IfcQuantitySet(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantitySet', 'IFC4X3', *args, **kwargs) + + +def IfcQuantityTime(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityTime', 'IFC4X3', *args, **kwargs) + + +def IfcQuantityVolume(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityVolume', 'IFC4X3', *args, **kwargs) + + +def IfcQuantityWeight(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityWeight', 'IFC4X3', *args, **kwargs) + + +def IfcRail(*args, **kwargs): return ifcopenshell.create_entity('IfcRail', 'IFC4X3', *args, **kwargs) + + +def IfcRailType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailType', 'IFC4X3', *args, **kwargs) + + +def IfcRailing(*args, **kwargs): return ifcopenshell.create_entity('IfcRailing', 'IFC4X3', *args, **kwargs) + + +def IfcRailingType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailingType', 'IFC4X3', *args, **kwargs) + + +def IfcRailway(*args, **kwargs): return ifcopenshell.create_entity('IfcRailway', 'IFC4X3', *args, **kwargs) + + +def IfcRailwayPart(*args, **kwargs): return ifcopenshell.create_entity('IfcRailwayPart', 'IFC4X3', *args, **kwargs) + + +def IfcRamp(*args, **kwargs): return ifcopenshell.create_entity('IfcRamp', 'IFC4X3', *args, **kwargs) + + +def IfcRampFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlight', 'IFC4X3', *args, **kwargs) + + +def IfcRampFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlightType', 'IFC4X3', *args, **kwargs) + + +def IfcRampType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampType', 'IFC4X3', *args, **kwargs) + + +def IfcRationalBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineCurveWithKnots', 'IFC4X3', *args, **kwargs) + + +def IfcRationalBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineSurfaceWithKnots', 'IFC4X3', *args, **kwargs) + + +def IfcRectangleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleHollowProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcRectangularPyramid(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularPyramid', 'IFC4X3', *args, **kwargs) + + +def IfcRectangularTrimmedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularTrimmedSurface', 'IFC4X3', *args, **kwargs) + + +def IfcRecurrencePattern(*args, **kwargs): return ifcopenshell.create_entity('IfcRecurrencePattern', 'IFC4X3', *args, **kwargs) + + +def IfcReference(*args, **kwargs): return ifcopenshell.create_entity('IfcReference', 'IFC4X3', *args, **kwargs) + + +def IfcReferent(*args, **kwargs): return ifcopenshell.create_entity('IfcReferent', 'IFC4X3', *args, **kwargs) + + +def IfcRegularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcRegularTimeSeries', 'IFC4X3', *args, **kwargs) + + +def IfcReinforcedSoil(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcedSoil', 'IFC4X3', *args, **kwargs) + + +def IfcReinforcementBarProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementBarProperties', 'IFC4X3', *args, **kwargs) + + +def IfcReinforcementDefinitionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementDefinitionProperties', 'IFC4X3', *args, **kwargs) + + +def IfcReinforcingBar(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBar', 'IFC4X3', *args, **kwargs) + + +def IfcReinforcingBarType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBarType', 'IFC4X3', *args, **kwargs) + + +def IfcReinforcingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElement', 'IFC4X3', *args, **kwargs) + + +def IfcReinforcingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElementType', 'IFC4X3', *args, **kwargs) + + +def IfcReinforcingMesh(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMesh', 'IFC4X3', *args, **kwargs) + + +def IfcReinforcingMeshType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMeshType', 'IFC4X3', *args, **kwargs) + + +def IfcRelAdheresToElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAdheresToElement', 'IFC4X3', *args, **kwargs) + + +def IfcRelAggregates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAggregates', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssigns(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssigns', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssignsToActor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToActor', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssignsToControl(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToControl', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssignsToGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroup', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssignsToGroupByFactor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroupByFactor', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssignsToProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProcess', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssignsToProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProduct', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssignsToResource(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToResource', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssociates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociates', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssociatesApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesApproval', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssociatesClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesClassification', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssociatesConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesConstraint', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssociatesDocument(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesDocument', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssociatesLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesLibrary', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssociatesMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesMaterial', 'IFC4X3', *args, **kwargs) + + +def IfcRelAssociatesProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcRelConnects(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnects', 'IFC4X3', *args, **kwargs) + + +def IfcRelConnectsElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsElements', 'IFC4X3', *args, **kwargs) + + +def IfcRelConnectsPathElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPathElements', 'IFC4X3', *args, **kwargs) + + +def IfcRelConnectsPortToElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPortToElement', 'IFC4X3', *args, **kwargs) + + +def IfcRelConnectsPorts(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPorts', 'IFC4X3', *args, **kwargs) + + +def IfcRelConnectsStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralActivity', 'IFC4X3', *args, **kwargs) + + +def IfcRelConnectsStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralMember', 'IFC4X3', *args, **kwargs) + + +def IfcRelConnectsWithEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithEccentricity', 'IFC4X3', *args, **kwargs) + + +def IfcRelConnectsWithRealizingElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithRealizingElements', 'IFC4X3', *args, **kwargs) + + +def IfcRelContainedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelContainedInSpatialStructure', 'IFC4X3', *args, **kwargs) + + +def IfcRelCoversBldgElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversBldgElements', 'IFC4X3', *args, **kwargs) + + +def IfcRelCoversSpaces(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversSpaces', 'IFC4X3', *args, **kwargs) + + +def IfcRelDeclares(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDeclares', 'IFC4X3', *args, **kwargs) + + +def IfcRelDecomposes(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDecomposes', 'IFC4X3', *args, **kwargs) + + +def IfcRelDefines(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefines', 'IFC4X3', *args, **kwargs) + + +def IfcRelDefinesByObject(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByObject', 'IFC4X3', *args, **kwargs) + + +def IfcRelDefinesByProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByProperties', 'IFC4X3', *args, **kwargs) + + +def IfcRelDefinesByTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByTemplate', 'IFC4X3', *args, **kwargs) + + +def IfcRelDefinesByType(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByType', 'IFC4X3', *args, **kwargs) + + +def IfcRelFillsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFillsElement', 'IFC4X3', *args, **kwargs) + + +def IfcRelFlowControlElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFlowControlElements', 'IFC4X3', *args, **kwargs) + + +def IfcRelInterferesElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelInterferesElements', 'IFC4X3', *args, **kwargs) + + +def IfcRelNests(*args, **kwargs): return ifcopenshell.create_entity('IfcRelNests', 'IFC4X3', *args, **kwargs) + + +def IfcRelPositions(*args, **kwargs): return ifcopenshell.create_entity('IfcRelPositions', 'IFC4X3', *args, **kwargs) + + +def IfcRelProjectsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelProjectsElement', 'IFC4X3', *args, **kwargs) + + +def IfcRelReferencedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelReferencedInSpatialStructure', 'IFC4X3', *args, **kwargs) + + +def IfcRelSequence(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSequence', 'IFC4X3', *args, **kwargs) + + +def IfcRelServicesBuildings(*args, **kwargs): return ifcopenshell.create_entity('IfcRelServicesBuildings', 'IFC4X3', *args, **kwargs) + + +def IfcRelSpaceBoundary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary', 'IFC4X3', *args, **kwargs) + + +def IfcRelSpaceBoundary1stLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary1stLevel', 'IFC4X3', *args, **kwargs) + + +def IfcRelSpaceBoundary2ndLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary2ndLevel', 'IFC4X3', *args, **kwargs) + + +def IfcRelVoidsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelVoidsElement', 'IFC4X3', *args, **kwargs) + + +def IfcRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcRelationship', 'IFC4X3', *args, **kwargs) + + +def IfcReparametrisedCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcReparametrisedCompositeCurveSegment', 'IFC4X3', *args, **kwargs) + + +def IfcRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentation', 'IFC4X3', *args, **kwargs) + + +def IfcRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationContext', 'IFC4X3', *args, **kwargs) + + +def IfcRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationItem', 'IFC4X3', *args, **kwargs) + + +def IfcRepresentationMap(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationMap', 'IFC4X3', *args, **kwargs) + + +def IfcResource(*args, **kwargs): return ifcopenshell.create_entity('IfcResource', 'IFC4X3', *args, **kwargs) + + +def IfcResourceApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceApprovalRelationship', 'IFC4X3', *args, **kwargs) + + +def IfcResourceConstraintRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceConstraintRelationship', 'IFC4X3', *args, **kwargs) + + +def IfcResourceLevelRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceLevelRelationship', 'IFC4X3', *args, **kwargs) + + +def IfcResourceTime(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceTime', 'IFC4X3', *args, **kwargs) + + +def IfcRevolvedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolid', 'IFC4X3', *args, **kwargs) + + +def IfcRevolvedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolidTapered', 'IFC4X3', *args, **kwargs) + + +def IfcRightCircularCone(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCone', 'IFC4X3', *args, **kwargs) + + +def IfcRightCircularCylinder(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCylinder', 'IFC4X3', *args, **kwargs) + + +def IfcRoad(*args, **kwargs): return ifcopenshell.create_entity('IfcRoad', 'IFC4X3', *args, **kwargs) + + +def IfcRoadPart(*args, **kwargs): return ifcopenshell.create_entity('IfcRoadPart', 'IFC4X3', *args, **kwargs) + + +def IfcRoof(*args, **kwargs): return ifcopenshell.create_entity('IfcRoof', 'IFC4X3', *args, **kwargs) + + +def IfcRoofType(*args, **kwargs): return ifcopenshell.create_entity('IfcRoofType', 'IFC4X3', *args, **kwargs) + + +def IfcRoot(*args, **kwargs): return ifcopenshell.create_entity('IfcRoot', 'IFC4X3', *args, **kwargs) + + +def IfcRoundedRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRoundedRectangleProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcSIUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcSIUnit', 'IFC4X3', *args, **kwargs) + + +def IfcSanitaryTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminal', 'IFC4X3', *args, **kwargs) + + +def IfcSanitaryTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminalType', 'IFC4X3', *args, **kwargs) + + +def IfcSchedulingTime(*args, **kwargs): return ifcopenshell.create_entity('IfcSchedulingTime', 'IFC4X3', *args, **kwargs) + + +def IfcSeamCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSeamCurve', 'IFC4X3', *args, **kwargs) + + +def IfcSecondOrderPolynomialSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSecondOrderPolynomialSpiral', 'IFC4X3', *args, **kwargs) + + +def IfcSectionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionProperties', 'IFC4X3', *args, **kwargs) + + +def IfcSectionReinforcementProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionReinforcementProperties', 'IFC4X3', *args, **kwargs) + + +def IfcSectionedSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolid', 'IFC4X3', *args, **kwargs) + + +def IfcSectionedSolidHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolidHorizontal', 'IFC4X3', *args, **kwargs) + + +def IfcSectionedSpine(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSpine', 'IFC4X3', *args, **kwargs) + + +def IfcSectionedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSurface', 'IFC4X3', *args, **kwargs) + + +def IfcSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcSegment', 'IFC4X3', *args, **kwargs) + + +def IfcSegmentedReferenceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSegmentedReferenceCurve', 'IFC4X3', *args, **kwargs) + + +def IfcSensor(*args, **kwargs): return ifcopenshell.create_entity('IfcSensor', 'IFC4X3', *args, **kwargs) + + +def IfcSensorType(*args, **kwargs): return ifcopenshell.create_entity('IfcSensorType', 'IFC4X3', *args, **kwargs) + + +def IfcSeventhOrderPolynomialSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSeventhOrderPolynomialSpiral', 'IFC4X3', *args, **kwargs) + + +def IfcShadingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDevice', 'IFC4X3', *args, **kwargs) + + +def IfcShadingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDeviceType', 'IFC4X3', *args, **kwargs) + + +def IfcShapeAspect(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeAspect', 'IFC4X3', *args, **kwargs) + + +def IfcShapeModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeModel', 'IFC4X3', *args, **kwargs) + + +def IfcShapeRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeRepresentation', 'IFC4X3', *args, **kwargs) + + +def IfcShellBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShellBasedSurfaceModel', 'IFC4X3', *args, **kwargs) + + +def IfcSign(*args, **kwargs): return ifcopenshell.create_entity('IfcSign', 'IFC4X3', *args, **kwargs) + + +def IfcSignType(*args, **kwargs): return ifcopenshell.create_entity('IfcSignType', 'IFC4X3', *args, **kwargs) + + +def IfcSignal(*args, **kwargs): return ifcopenshell.create_entity('IfcSignal', 'IFC4X3', *args, **kwargs) + + +def IfcSignalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSignalType', 'IFC4X3', *args, **kwargs) + + +def IfcSimpleProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcSimpleProperty', 'IFC4X3', *args, **kwargs) + + +def IfcSimplePropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcSimplePropertyTemplate', 'IFC4X3', *args, **kwargs) + + +def IfcSineSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSineSpiral', 'IFC4X3', *args, **kwargs) + + +def IfcSite(*args, **kwargs): return ifcopenshell.create_entity('IfcSite', 'IFC4X3', *args, **kwargs) + + +def IfcSlab(*args, **kwargs): return ifcopenshell.create_entity('IfcSlab', 'IFC4X3', *args, **kwargs) + + +def IfcSlabType(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabType', 'IFC4X3', *args, **kwargs) + + +def IfcSlippageConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcSlippageConnectionCondition', 'IFC4X3', *args, **kwargs) + + +def IfcSolarDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDevice', 'IFC4X3', *args, **kwargs) + + +def IfcSolarDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDeviceType', 'IFC4X3', *args, **kwargs) + + +def IfcSolidModel(*args, **kwargs): return ifcopenshell.create_entity('IfcSolidModel', 'IFC4X3', *args, **kwargs) + + +def IfcSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcSpace', 'IFC4X3', *args, **kwargs) + + +def IfcSpaceHeater(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeater', 'IFC4X3', *args, **kwargs) + + +def IfcSpaceHeaterType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeaterType', 'IFC4X3', *args, **kwargs) + + +def IfcSpaceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceType', 'IFC4X3', *args, **kwargs) + + +def IfcSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElement', 'IFC4X3', *args, **kwargs) + + +def IfcSpatialElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElementType', 'IFC4X3', *args, **kwargs) + + +def IfcSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElement', 'IFC4X3', *args, **kwargs) + + +def IfcSpatialStructureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElementType', 'IFC4X3', *args, **kwargs) + + +def IfcSpatialZone(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZone', 'IFC4X3', *args, **kwargs) + + +def IfcSpatialZoneType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZoneType', 'IFC4X3', *args, **kwargs) + + +def IfcSphere(*args, **kwargs): return ifcopenshell.create_entity('IfcSphere', 'IFC4X3', *args, **kwargs) + + +def IfcSphericalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSphericalSurface', 'IFC4X3', *args, **kwargs) + + +def IfcSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSpiral', 'IFC4X3', *args, **kwargs) + + +def IfcStackTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminal', 'IFC4X3', *args, **kwargs) + + +def IfcStackTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminalType', 'IFC4X3', *args, **kwargs) + + +def IfcStair(*args, **kwargs): return ifcopenshell.create_entity('IfcStair', 'IFC4X3', *args, **kwargs) + + +def IfcStairFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlight', 'IFC4X3', *args, **kwargs) + + +def IfcStairFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlightType', 'IFC4X3', *args, **kwargs) + + +def IfcStairType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairType', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAction', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralActivity', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralAnalysisModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAnalysisModel', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnection', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnectionCondition', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralCurveAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveAction', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralCurveConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveConnection', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralCurveMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMember', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralCurveMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMemberVarying', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralCurveReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveReaction', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralItem', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralLinearAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLinearAction', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralLoad(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoad', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralLoadCase(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadCase', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralLoadConfiguration(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadConfiguration', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralLoadGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadGroup', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralLoadLinearForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadLinearForce', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralLoadOrResult(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadOrResult', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralLoadPlanarForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadPlanarForce', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacement(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacement', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacementDistortion(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacementDistortion', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralLoadSingleForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForce', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralLoadSingleForceWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForceWarping', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralLoadStatic(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadStatic', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralLoadTemperature(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadTemperature', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralMember', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralPlanarAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPlanarAction', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralPointAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointAction', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralPointConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointConnection', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralPointReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointReaction', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralReaction', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralResultGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralResultGroup', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralSurfaceAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceAction', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralSurfaceConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceConnection', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralSurfaceMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMember', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralSurfaceMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMemberVarying', 'IFC4X3', *args, **kwargs) + + +def IfcStructuralSurfaceReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceReaction', 'IFC4X3', *args, **kwargs) + + +def IfcStyleModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStyleModel', 'IFC4X3', *args, **kwargs) + + +def IfcStyledItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledItem', 'IFC4X3', *args, **kwargs) + + +def IfcStyledRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledRepresentation', 'IFC4X3', *args, **kwargs) + + +def IfcSubContractResource(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResource', 'IFC4X3', *args, **kwargs) + + +def IfcSubContractResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResourceType', 'IFC4X3', *args, **kwargs) + + +def IfcSubedge(*args, **kwargs): return ifcopenshell.create_entity('IfcSubedge', 'IFC4X3', *args, **kwargs) + + +def IfcSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSurface', 'IFC4X3', *args, **kwargs) + + +def IfcSurfaceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurve', 'IFC4X3', *args, **kwargs) + + +def IfcSurfaceCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurveSweptAreaSolid', 'IFC4X3', *args, **kwargs) + + +def IfcSurfaceFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceFeature', 'IFC4X3', *args, **kwargs) + + +def IfcSurfaceOfLinearExtrusion(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfLinearExtrusion', 'IFC4X3', *args, **kwargs) + + +def IfcSurfaceOfRevolution(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfRevolution', 'IFC4X3', *args, **kwargs) + + +def IfcSurfaceReinforcementArea(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceReinforcementArea', 'IFC4X3', *args, **kwargs) + + +def IfcSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyle', 'IFC4X3', *args, **kwargs) + + +def IfcSurfaceStyleLighting(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleLighting', 'IFC4X3', *args, **kwargs) + + +def IfcSurfaceStyleRefraction(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRefraction', 'IFC4X3', *args, **kwargs) + + +def IfcSurfaceStyleRendering(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRendering', 'IFC4X3', *args, **kwargs) + + +def IfcSurfaceStyleShading(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleShading', 'IFC4X3', *args, **kwargs) + + +def IfcSurfaceStyleWithTextures(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleWithTextures', 'IFC4X3', *args, **kwargs) + + +def IfcSurfaceTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceTexture', 'IFC4X3', *args, **kwargs) + + +def IfcSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptAreaSolid', 'IFC4X3', *args, **kwargs) + + +def IfcSweptDiskSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolid', 'IFC4X3', *args, **kwargs) + + +def IfcSweptDiskSolidPolygonal(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolidPolygonal', 'IFC4X3', *args, **kwargs) + + +def IfcSweptSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptSurface', 'IFC4X3', *args, **kwargs) + + +def IfcSwitchingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDevice', 'IFC4X3', *args, **kwargs) + + +def IfcSwitchingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDeviceType', 'IFC4X3', *args, **kwargs) + + +def IfcSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcSystem', 'IFC4X3', *args, **kwargs) + + +def IfcSystemFurnitureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElement', 'IFC4X3', *args, **kwargs) + + +def IfcSystemFurnitureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElementType', 'IFC4X3', *args, **kwargs) + + +def IfcTShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTShapeProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcTable(*args, **kwargs): return ifcopenshell.create_entity('IfcTable', 'IFC4X3', *args, **kwargs) + + +def IfcTableColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcTableColumn', 'IFC4X3', *args, **kwargs) + + +def IfcTableRow(*args, **kwargs): return ifcopenshell.create_entity('IfcTableRow', 'IFC4X3', *args, **kwargs) + + +def IfcTank(*args, **kwargs): return ifcopenshell.create_entity('IfcTank', 'IFC4X3', *args, **kwargs) + + +def IfcTankType(*args, **kwargs): return ifcopenshell.create_entity('IfcTankType', 'IFC4X3', *args, **kwargs) + + +def IfcTask(*args, **kwargs): return ifcopenshell.create_entity('IfcTask', 'IFC4X3', *args, **kwargs) + + +def IfcTaskTime(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTime', 'IFC4X3', *args, **kwargs) + + +def IfcTaskTimeRecurring(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTimeRecurring', 'IFC4X3', *args, **kwargs) + + +def IfcTaskType(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskType', 'IFC4X3', *args, **kwargs) + + +def IfcTelecomAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcTelecomAddress', 'IFC4X3', *args, **kwargs) + + +def IfcTendon(*args, **kwargs): return ifcopenshell.create_entity('IfcTendon', 'IFC4X3', *args, **kwargs) + + +def IfcTendonAnchor(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchor', 'IFC4X3', *args, **kwargs) + + +def IfcTendonAnchorType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchorType', 'IFC4X3', *args, **kwargs) + + +def IfcTendonConduit(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduit', 'IFC4X3', *args, **kwargs) + + +def IfcTendonConduitType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduitType', 'IFC4X3', *args, **kwargs) + + +def IfcTendonType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonType', 'IFC4X3', *args, **kwargs) + + +def IfcTessellatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedFaceSet', 'IFC4X3', *args, **kwargs) + + +def IfcTessellatedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedItem', 'IFC4X3', *args, **kwargs) + + +def IfcTextLiteral(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteral', 'IFC4X3', *args, **kwargs) + + +def IfcTextLiteralWithExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteralWithExtent', 'IFC4X3', *args, **kwargs) + + +def IfcTextStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyle', 'IFC4X3', *args, **kwargs) + + +def IfcTextStyleFontModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleFontModel', 'IFC4X3', *args, **kwargs) + + +def IfcTextStyleForDefinedFont(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleForDefinedFont', 'IFC4X3', *args, **kwargs) + + +def IfcTextStyleTextModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleTextModel', 'IFC4X3', *args, **kwargs) + + +def IfcTextureCoordinate(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinate', 'IFC4X3', *args, **kwargs) + + +def IfcTextureCoordinateGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateGenerator', 'IFC4X3', *args, **kwargs) + + +def IfcTextureCoordinateIndices(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateIndices', 'IFC4X3', *args, **kwargs) + + +def IfcTextureCoordinateIndicesWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateIndicesWithVoids', 'IFC4X3', *args, **kwargs) + + +def IfcTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureMap', 'IFC4X3', *args, **kwargs) + + +def IfcTextureVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertex', 'IFC4X3', *args, **kwargs) + + +def IfcTextureVertexList(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertexList', 'IFC4X3', *args, **kwargs) + + +def IfcThirdOrderPolynomialSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcThirdOrderPolynomialSpiral', 'IFC4X3', *args, **kwargs) + + +def IfcTimePeriod(*args, **kwargs): return ifcopenshell.create_entity('IfcTimePeriod', 'IFC4X3', *args, **kwargs) + + +def IfcTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeries', 'IFC4X3', *args, **kwargs) + + +def IfcTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeriesValue', 'IFC4X3', *args, **kwargs) + + +def IfcTopologicalRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologicalRepresentationItem', 'IFC4X3', *args, **kwargs) + + +def IfcTopologyRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologyRepresentation', 'IFC4X3', *args, **kwargs) + + +def IfcToroidalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcToroidalSurface', 'IFC4X3', *args, **kwargs) + + +def IfcTrackElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTrackElement', 'IFC4X3', *args, **kwargs) + + +def IfcTrackElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTrackElementType', 'IFC4X3', *args, **kwargs) + + +def IfcTransformer(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformer', 'IFC4X3', *args, **kwargs) + + +def IfcTransformerType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformerType', 'IFC4X3', *args, **kwargs) + + +def IfcTransportElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElement', 'IFC4X3', *args, **kwargs) + + +def IfcTransportElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElementType', 'IFC4X3', *args, **kwargs) + + +def IfcTransportationDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportationDevice', 'IFC4X3', *args, **kwargs) + + +def IfcTransportationDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportationDeviceType', 'IFC4X3', *args, **kwargs) + + +def IfcTrapeziumProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTrapeziumProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcTriangulatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedFaceSet', 'IFC4X3', *args, **kwargs) + + +def IfcTriangulatedIrregularNetwork(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedIrregularNetwork', 'IFC4X3', *args, **kwargs) + + +def IfcTrimmedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcTrimmedCurve', 'IFC4X3', *args, **kwargs) + + +def IfcTubeBundle(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundle', 'IFC4X3', *args, **kwargs) + + +def IfcTubeBundleType(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundleType', 'IFC4X3', *args, **kwargs) + + +def IfcTypeObject(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeObject', 'IFC4X3', *args, **kwargs) + + +def IfcTypeProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProcess', 'IFC4X3', *args, **kwargs) + + +def IfcTypeProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProduct', 'IFC4X3', *args, **kwargs) + + +def IfcTypeResource(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeResource', 'IFC4X3', *args, **kwargs) + + +def IfcUShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcUShapeProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcUnitAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitAssignment', 'IFC4X3', *args, **kwargs) + + +def IfcUnitaryControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElement', 'IFC4X3', *args, **kwargs) + + +def IfcUnitaryControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElementType', 'IFC4X3', *args, **kwargs) + + +def IfcUnitaryEquipment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipment', 'IFC4X3', *args, **kwargs) + + +def IfcUnitaryEquipmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipmentType', 'IFC4X3', *args, **kwargs) + + +def IfcValve(*args, **kwargs): return ifcopenshell.create_entity('IfcValve', 'IFC4X3', *args, **kwargs) + + +def IfcValveType(*args, **kwargs): return ifcopenshell.create_entity('IfcValveType', 'IFC4X3', *args, **kwargs) + + +def IfcVector(*args, **kwargs): return ifcopenshell.create_entity('IfcVector', 'IFC4X3', *args, **kwargs) + + +def IfcVehicle(*args, **kwargs): return ifcopenshell.create_entity('IfcVehicle', 'IFC4X3', *args, **kwargs) + + +def IfcVehicleType(*args, **kwargs): return ifcopenshell.create_entity('IfcVehicleType', 'IFC4X3', *args, **kwargs) + + +def IfcVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcVertex', 'IFC4X3', *args, **kwargs) + + +def IfcVertexLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexLoop', 'IFC4X3', *args, **kwargs) + + +def IfcVertexPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexPoint', 'IFC4X3', *args, **kwargs) + + +def IfcVibrationDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamper', 'IFC4X3', *args, **kwargs) + + +def IfcVibrationDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamperType', 'IFC4X3', *args, **kwargs) + + +def IfcVibrationIsolator(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolator', 'IFC4X3', *args, **kwargs) + + +def IfcVibrationIsolatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolatorType', 'IFC4X3', *args, **kwargs) + + +def IfcVirtualElement(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualElement', 'IFC4X3', *args, **kwargs) + + +def IfcVirtualGridIntersection(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualGridIntersection', 'IFC4X3', *args, **kwargs) + + +def IfcVoidingFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcVoidingFeature', 'IFC4X3', *args, **kwargs) + + +def IfcWall(*args, **kwargs): return ifcopenshell.create_entity('IfcWall', 'IFC4X3', *args, **kwargs) + + +def IfcWallStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallStandardCase', 'IFC4X3', *args, **kwargs) + + +def IfcWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcWallType', 'IFC4X3', *args, **kwargs) + + +def IfcWasteTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminal', 'IFC4X3', *args, **kwargs) + + +def IfcWasteTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminalType', 'IFC4X3', *args, **kwargs) + + +def IfcWindow(*args, **kwargs): return ifcopenshell.create_entity('IfcWindow', 'IFC4X3', *args, **kwargs) + + +def IfcWindowLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowLiningProperties', 'IFC4X3', *args, **kwargs) + + +def IfcWindowPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowPanelProperties', 'IFC4X3', *args, **kwargs) + + +def IfcWindowType(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowType', 'IFC4X3', *args, **kwargs) + + +def IfcWorkCalendar(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkCalendar', 'IFC4X3', *args, **kwargs) + + +def IfcWorkControl(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkControl', 'IFC4X3', *args, **kwargs) + + +def IfcWorkPlan(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkPlan', 'IFC4X3', *args, **kwargs) + + +def IfcWorkSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkSchedule', 'IFC4X3', *args, **kwargs) + + +def IfcWorkTime(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkTime', 'IFC4X3', *args, **kwargs) + + +def IfcZShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcZShapeProfileDef', 'IFC4X3', *args, **kwargs) + + +def IfcZone(*args, **kwargs): return ifcopenshell.create_entity('IfcZone', 'IFC4X3', *args, **kwargs) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcBoxAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcBoxAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['top-left','top-middle','top-right','middle-left','center','middle-right','bottom-left','bottom-middle','bottom-right'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCardinalPointReference_GreaterThanZero: + SCOPE = "type" + TYPE_NAME = "IfcCardinalPointReference" + RULE_NAME = "GreaterThanZero" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCompoundPlaneAngleMeasure_MinutesInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MinutesInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[2 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_SecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "SecondsInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[3 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_MicrosecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MicrosecondsInRange" + + @staticmethod + def __call__(self): + + + assert (sizeof(self) == 3) or ((abs(self[4 - 1])) < 1000000) + + + + +class IfcCompoundPlaneAngleMeasure_ConsistentSign: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "ConsistentSign" + + @staticmethod + def __call__(self): + + + assert (((self[1 - 1]) >= 0) and ((self[2 - 1]) >= 0) and ((self[3 - 1]) >= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) >= 0))) or (((self[1 - 1]) <= 0) and ((self[2 - 1]) <= 0) and ((self[3 - 1]) <= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) <= 0))) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDayInMonthNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInMonthNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 31 + + + + + +class IfcDayInWeekNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInWeekNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 7 + + + + + + + + + + + + + + + + + +class IfcDimensionCount_WR1: + SCOPE = "type" + TYPE_NAME = "IfcDimensionCount" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0 < self <= 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFontStyle_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontStyle" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','italic','oblique'] + + + + + +class IfcFontVariant_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontVariant" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps'] + + + + + +class IfcFontWeight_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontWeight" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps','100','200','300','400','500','600','700','800','900'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcHeatingValueMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcHeatingValueMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMonthInYearNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcMonthInYearNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 12 + + + + + + + + + + + + + + +class IfcNonNegativeLengthMeasure_NotNegative: + SCOPE = "type" + TYPE_NAME = "IfcNonNegativeLengthMeasure" + RULE_NAME = "NotNegative" + + @staticmethod + def __call__(self): + + + assert self >= 0. + + + + + +class IfcNormalisedRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcNormalisedRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPHMeasure_WR21: + SCOPE = "type" + TYPE_NAME = "IfcPHMeasure" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 14.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPositiveInteger_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveInteger" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + +class IfcPositiveLengthMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveLengthMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositivePlaneAngleMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositivePlaneAngleMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositiveRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcSpecularRoughness_WR1: + SCOPE = "type" + TYPE_NAME = "IfcSpecularRoughness" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTextAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['left','right','center','justify'] + + + + + +class IfcTextDecoration_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextDecoration" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['none','underline','overline','line-through','blink'] + + + + + + + + + + + + + + +class IfcTextTransformation_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextTransformation" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['capitalize','uppercase','lowercase','none'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcActorRole_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcActorRole" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + role = self.Role + + assert (role != IfcRoleEnum.USERDEFINED) or ((role == IfcRoleEnum.USERDEFINED) and exists(self.UserDefinedRole)) + + + + + +class IfcActuator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcActuator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcactuatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcActuatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + purpose = self.Purpose + + assert (not exists(purpose)) or ((purpose != IfcAddressTypeEnum.USERDEFINED) or ((purpose == IfcAddressTypeEnum.USERDEFINED) and exists(self.UserDefinedPurpose))) + + + + + +class IfcAdvancedBrep_HasAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrep" + RULE_NAME = "HasAdvancedFaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([afs for afs in self.Outer.CfsFaces if not 'ifc4x3.ifcadvancedface' in typeof(afs)])) == 0 + + + + + +class IfcAdvancedBrepWithVoids_VoidsHaveAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrepWithVoids" + RULE_NAME = "VoidsHaveAdvancedFaces" + + @staticmethod + def __call__(self): + voids = self.Voids + + assert (sizeof([vsh for vsh in voids if (sizeof([afs for afs in vsh.CfsFaces if not 'ifc4x3.ifcadvancedface' in typeof(afs)])) == 0])) == 0 + + + + + +class IfcAdvancedFace_ApplicableEdgeCurves: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableEdgeCurves" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x3.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not (sizeof(['ifc4x3.ifcline','ifc4x3.ifcconic','ifc4x3.ifcpolyline','ifc4x3.ifcbsplinecurve'] * typeof(oe.EdgeElement.EdgeGeometry))) == 1])) == 0])) == 0 + + + + +class IfcAdvancedFace_ApplicableSurface: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableSurface" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3.ifcelementarysurface','ifc4x3.ifcsweptsurface','ifc4x3.ifcbsplinesurface'] * typeof(self.FaceSurface))) == 1 + + + + +class IfcAdvancedFace_RequiresEdgeCurve: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "RequiresEdgeCurve" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x3.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not 'ifc4x3.ifcedgecurve' in typeof(oe.EdgeElement)])) == 0])) == 0 + + + + + +class IfcAirTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcairterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminalBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcairterminalboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirToAirHeatRecovery_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirToAirHeatRecovery_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcairtoairheatrecoverytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirToAirHeatRecoveryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecoveryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAlarm_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAlarm_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcalarmtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAlarmType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarmType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcApproval_HasIdentifierOrName: + SCOPE = "entity" + TYPE_NAME = "IfcApproval" + RULE_NAME = "HasIdentifierOrName" + + @staticmethod + def __call__(self): + identifier = self.Identifier + name = self.Name + + assert exists(identifier) or exists(name) + + + + + + + + +class IfcArbitraryClosedProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert outercurve.Dim == 2 + + + + +class IfcArbitraryClosedProfileDef_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x3.ifcline' in typeof(outercurve) + + + + +class IfcArbitraryClosedProfileDef_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x3.ifcoffsetcurve2d' in typeof(outercurve) + + + + + +class IfcArbitraryOpenProfileDef_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3.ifccenterlineprofiledef' in typeof(self)) or (self.ProfileType == IfcProfileTypeEnum.CURVE) + + + + +class IfcArbitraryOpenProfileDef_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + curve = self.Curve + + assert curve.Dim == 2 + + + + + +class IfcArbitraryProfileDefWithVoids_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == area + + + + +class IfcArbitraryProfileDefWithVoids_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if temp.Dim != 2])) == 0 + + + + +class IfcArbitraryProfileDefWithVoids_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if 'ifc4x3.ifcline' in typeof(temp)])) == 0 + + + + + + + + +class IfcAsymmetricIShapeProfileDef_ValidBottomFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidBottomFilletRadius" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + bottomflangefilletradius = self.BottomFlangeFilletRadius + + assert (not exists(bottomflangefilletradius)) or (bottomflangefilletradius <= ((bottomflangewidth - webthickness) / 2.)) + + + + +class IfcAsymmetricIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + bottomflangethickness = self.BottomFlangeThickness + topflangethickness = self.TopFlangeThickness + + assert (not exists(topflangethickness)) or ((bottomflangethickness + topflangethickness) < overalldepth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidTopFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidTopFilletRadius" + + @staticmethod + def __call__(self): + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + topflangefilletradius = self.TopFlangeFilletRadius + + assert (not exists(topflangefilletradius)) or (topflangefilletradius <= ((topflangewidth - webthickness) / 2.)) + + + + +class IfcAsymmetricIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + + assert (webthickness < bottomflangewidth) and (webthickness < topflangewidth) + + + + + +class IfcAudioVisualAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAudioVisualAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcaudiovisualappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAudioVisualApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAxis1Placement_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis1Placement_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis1Placement_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3.ifccartesianpoint' in typeof(self.Location) + + + + +def calc_IfcAxis1Placement_Z(self): + axis = self.Axis + return \ + nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + + + + +class IfcAxis2Placement2D_LocationIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIs2D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 2 + + + + +class IfcAxis2Placement2D_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3.ifccartesianpoint' in typeof(self.Location) + + + + +class IfcAxis2Placement2D_RefDirIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "RefDirIs2D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 2) + + + + +def calc_IfcAxis2Placement2D_P(self): + refdirection = self.RefDirection + return \ + IfcBuild2Axes(refdirection) + + + + +class IfcAxis2Placement3D_AxisAndRefDirProvision: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisAndRefDirProvision" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert not exists(axis) ^ exists(refdirection) + + + + +class IfcAxis2Placement3D_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis2Placement3D_AxisToRefDirPosition: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisToRefDirPosition" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + +class IfcAxis2Placement3D_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis2Placement3D_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3.ifccartesianpoint' in typeof(self.Location) + + + + +class IfcAxis2Placement3D_RefDirIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "RefDirIs3D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 3) + + + + +def calc_IfcAxis2Placement3D_P(self): + axis = self.Axis + refdirection = self.RefDirection + return \ + IfcBuildAxes(axis,refdirection) + + + + +class IfcAxis2PlacementLinear_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2PlacementLinear" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3.ifcpointbydistanceexpression' in typeof(self.Location) + + + + +class IfcAxis2PlacementLinear_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2PlacementLinear" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + + +class IfcBSplineCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + controlpointslist = self.ControlPointsList + + assert (sizeof([temp for temp in controlpointslist if temp.Dim != (controlpointslist[1 - 1].Dim)])) == 0 + + + + +def calc_IfcBSplineCurve_UpperIndexOnControlPoints(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineCurve_ControlPoints(self): + controlpointslist = self.ControlPointsList + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + return \ + IfcListToArray(controlpointslist,0,upperindexoncontrolpoints) + + + + +class IfcBSplineCurveWithKnots_ConsistentBSpline: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "ConsistentBSpline" + + @staticmethod + def __call__(self): + degree = self.Degree + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + knotmultiplicities = self.KnotMultiplicities + knots = self.Knots + upperindexonknots = self.UpperIndexOnKnots + + assert IfcConstraintsParamBSpline(degree,upperindexonknots,upperindexoncontrolpoints,knotmultiplicities,knots) + + + + +class IfcBSplineCurveWithKnots_CorrespondingKnotLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "CorrespondingKnotLists" + + @staticmethod + def __call__(self): + knotmultiplicities = self.KnotMultiplicities + upperindexonknots = self.UpperIndexOnKnots + + assert sizeof(knotmultiplicities) == upperindexonknots + + + + +def calc_IfcBSplineCurveWithKnots_UpperIndexOnKnots(self): + knots = self.Knots + return \ + sizeof(knots) + + + + +def calc_IfcBSplineSurface_UUpper(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineSurface_VUpper(self): + controlpointslist = self.ControlPointsList + return \ + (sizeof(controlpointslist[1 - 1])) - 1 + + + +def calc_IfcBSplineSurface_ControlPoints(self): + controlpointslist = self.ControlPointsList + uupper = self.UUpper + vupper = self.VUpper + return \ + IfcMakeArrayOfArray(controlpointslist,0,uupper,0,vupper) + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingULists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingULists" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + knotuupper = self.KnotUUpper + + assert sizeof(umultiplicities) == knotuupper + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingVLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingVLists" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + knotvupper = self.KnotVUpper + + assert sizeof(vmultiplicities) == knotvupper + + + + +class IfcBSplineSurfaceWithKnots_UDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "UDirectionConstraints" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + uknots = self.UKnots + knotuupper = self.KnotUUpper + + assert IfcConstraintsParamBSpline(self.UDegree,knotuupper,self.UUpper,umultiplicities,uknots) + + + + +class IfcBSplineSurfaceWithKnots_VDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "VDirectionConstraints" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + vknots = self.VKnots + knotvupper = self.KnotVUpper + + assert IfcConstraintsParamBSpline(self.VDegree,knotvupper,self.VUpper,vmultiplicities,vknots) + + + + +def calc_IfcBSplineSurfaceWithKnots_KnotVUpper(self): + vknots = self.VKnots + return \ + sizeof(vknots) + + + +def calc_IfcBSplineSurfaceWithKnots_KnotUUpper(self): + uknots = self.UKnots + return \ + sizeof(uknots) + + + + +class IfcBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBearing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBearing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcbearingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBearingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBlobTexture_RasterCodeByteStream: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "RasterCodeByteStream" + + @staticmethod + def __call__(self): + rastercode = self.RasterCode + + assert (blength(rastercode) % 8) == 0 + + + + +class IfcBlobTexture_SupportedRasterFormat: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "SupportedRasterFormat" + + @staticmethod + def __call__(self): + + + assert self.RasterFormat in ['bmp','jpg','gif','png'] + + + + + + + + +class IfcBoiler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBoiler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcboilertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBoilerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoilerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBooleanClippingResult_FirstOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "FirstOperandType" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert ('ifc4x3.ifcsweptareasolid' in typeof(firstoperand)) or ('ifc4x3.ifcsweptdiscsolid' in typeof(firstoperand)) or ('ifc4x3.ifcbooleanclippingresult' in typeof(firstoperand)) + + + + +class IfcBooleanClippingResult_OperatorType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "OperatorType" + + @staticmethod + def __call__(self): + operator = self.Operator + + assert operator == difference + + + + +class IfcBooleanClippingResult_SecondOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "SecondOperandType" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert 'ifc4x3.ifchalfspacesolid' in typeof(secondoperand) + + + + + +class IfcBooleanResult_FirstOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "FirstOperandClosed" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert (not 'ifc4x3.ifctessellatedfaceset' in typeof(firstoperand)) or (exists(firstoperand.Closed) and firstoperand.Closed) + + + + +class IfcBooleanResult_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + secondoperand = self.SecondOperand + + assert firstoperand.Dim == secondoperand.Dim + + + + +class IfcBooleanResult_SecondOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SecondOperandClosed" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert (not 'ifc4x3.ifctessellatedfaceset' in typeof(secondoperand)) or (exists(secondoperand.Closed) and secondoperand.Closed) + + + + +def calc_IfcBooleanResult_Dim(self): + firstoperand = self.FirstOperand + return \ + firstoperand.Dim + + + + + + + + + + +class IfcBoundaryCurve_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBoundaryCurve" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + + + assert self.ClosedCurve + + + + + + + + + + + + + + + + + + + + + + + +def calc_IfcBoundingBox_Dim(self): + + return \ + 3 + + + + +class IfcBoxedHalfSpace_UnboundedSurface: + SCOPE = "entity" + TYPE_NAME = "IfcBoxedHalfSpace" + RULE_NAME = "UnboundedSurface" + + @staticmethod + def __call__(self): + + + assert not 'ifc4x3.ifccurveboundedplane' in typeof(self.BaseSurface) + + + + + +class IfcBridge_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBridge" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBridgeTypeEnum.USERDEFINED) or ((predefinedtype == IfcBridgeTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcBridgePart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBridgePart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBridgePartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBridgePartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcBuildingElementPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementPart_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcbuildingelementparttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementPartType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPartType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBuildingElementProxy_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementProxy_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcbuildingelementproxytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + +class IfcBuildingElementProxy_HasObjectName: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "HasObjectName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcBuildingElementProxyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcBuildingSystem_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingSystem" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingSystemTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingSystemTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcBuiltElement_MaxOneMaterialAssociation: + SCOPE = "entity" + TYPE_NAME = "IfcBuiltElement" + RULE_NAME = "MaxOneMaterialAssociation" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.HasAssociations if 'ifc4x3.ifcrelassociatesmaterial' in typeof(temp)])) <= 1 + + + + + + + + +class IfcBuiltSystem_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuiltSystem" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuiltSystemTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuiltSystemTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcBurner_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBurner_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcburnertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBurnerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurnerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCShapeProfileDef_ValidGirth: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidGirth" + + @staticmethod + def __call__(self): + depth = self.Depth + girth = self.Girth + + assert girth < (depth / 2.) + + + + +class IfcCShapeProfileDef_ValidInternalFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidInternalFilletRadius" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + internalfilletradius = self.InternalFilletRadius + + assert (not exists(internalfilletradius)) or ((internalfilletradius <= ((width / 2.) - wallthickness)) and (internalfilletradius <= ((depth / 2.) - wallthickness))) + + + + +class IfcCShapeProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + + assert (wallthickness < (width / 2.)) and (wallthickness < (depth / 2.)) + + + + + +class IfcCableCarrierFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccablecarrierfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableCarrierSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccablecarriersegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccablefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccablesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCaissonFoundation_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCaissonFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccaissonfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCaissonFoundationType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundationType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCartesianPoint_CP2Dor3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianPoint" + RULE_NAME = "CP2Dor3D" + + @staticmethod + def __call__(self): + coordinates = self.Coordinates + + assert hiindex(coordinates) >= 2 + + + + +def calc_IfcCartesianPoint_Dim(self): + coordinates = self.Coordinates + return \ + hiindex(coordinates) + + + + +def calc_IfcCartesianPointList_Dim(self): + + return \ + IfcPointListDim(self) + + + + + + + + + + +class IfcCartesianTransformationOperator_ScaleGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator" + RULE_NAME = "ScaleGreaterZero" + + @staticmethod + def __call__(self): + scl = self.Scl + + assert scl > 0.0 + + + + +def calc_IfcCartesianTransformationOperator_Scl(self): + scale = self.Scale + return \ + nvl(scale,1.0) + + + +def calc_IfcCartesianTransformationOperator_Dim(self): + localorigin = self.LocalOrigin + return \ + localorigin.Dim + + + + +class IfcCartesianTransformationOperator2D_Axis1Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis1Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 2) + + + + +class IfcCartesianTransformationOperator2D_Axis2Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis2Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 2) + + + + +class IfcCartesianTransformationOperator2D_DimEqual2: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "DimEqual2" + + @staticmethod + def __call__(self): + + + assert self.Dim == 2 + + + + +def calc_IfcCartesianTransformationOperator2D_U(self): + + return \ + IfcBaseAxis(2,self.Axis1,self.Axis2,None) + + + + +class IfcCartesianTransformationOperator2DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator2DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + + +class IfcCartesianTransformationOperator3D_Axis1Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis1Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis2Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis2Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis3Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis3Is3D" + + @staticmethod + def __call__(self): + axis3 = self.Axis3 + + assert (not exists(axis3)) or (axis3.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_DimIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "DimIs3D" + + @staticmethod + def __call__(self): + + + assert self.Dim == 3 + + + + +def calc_IfcCartesianTransformationOperator3D_U(self): + axis3 = self.Axis3 + return \ + IfcBaseAxis(3,self.Axis1,self.Axis2,axis3) + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale3GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale3GreaterZero" + + @staticmethod + def __call__(self): + scl3 = self.Scl3 + + assert scl3 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl3(self): + scale3 = self.Scale3 + return \ + nvl(scale3,self.Scl) + + + + + + + +class IfcChiller_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChiller_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcchillertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChillerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChillerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcChimney_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChimney_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcchimneytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChimneyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimneyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcCircleHollowProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCircleHollowProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert wallthickness < self.Radius + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoil_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccoiltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoilType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoilType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcColumn_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcColumn_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccolumntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcColumnType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumnType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcComplexProperty_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert (sizeof([temp for temp in hasproperties if self == temp])) == 0 + + + + +class IfcComplexProperty_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + +class IfcComplexPropertyTemplate_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert (sizeof([temp for temp in haspropertytemplates if self == temp])) == 0 + + + + +class IfcComplexPropertyTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + + +class IfcCompositeCurve_CurveContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "CurveContinuous" + + @staticmethod + def __call__(self): + segments = self.Segments + closedcurve = self.ClosedCurve + + assert ((not closedcurve) and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 1)) or (closedcurve and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 0)) + + + + +class IfcCompositeCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (sizeof([temp for temp in segments if temp.Dim != (segments[1 - 1].Dim)])) == 0 + + + + +def calc_IfcCompositeCurve_NSegments(self): + segments = self.Segments + return \ + sizeof(segments) + + + +def calc_IfcCompositeCurve_ClosedCurve(self): + segments = self.Segments + nsegments = self.NSegments + return \ + (segments[nsegments - 1].Transition) != discontinuous + + + + +class IfcCompositeCurveOnSurface_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveOnSurface" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + + assert sizeof(basissurface) > 0 + + + + +def calc_IfcCompositeCurveOnSurface_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + +class IfcCompositeCurveSegment_ParentIsBoundedCurve: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveSegment" + RULE_NAME = "ParentIsBoundedCurve" + + @staticmethod + def __call__(self): + parentcurve = self.ParentCurve + + assert 'ifc4x3.ifcboundedcurve' in typeof(parentcurve) + + + + +def calc_IfcCompositeCurveSegment_Dim(self): + parentcurve = self.ParentCurve + return \ + parentcurve.Dim + + + + +class IfcCompositeProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if temp.ProfileType != (profiles[1 - 1].ProfileType)])) == 0 + + + + +class IfcCompositeProfileDef_NoRecursion: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "NoRecursion" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if 'ifc4x3.ifccompositeprofiledef' in typeof(temp)])) == 0 + + + + + +class IfcCompressor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCompressor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccompressortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCompressorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCondenser_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCondenser_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccondensertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCondenserType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenserType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcConstraint_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcConstraint" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + constraintgrade = self.ConstraintGrade + + assert (constraintgrade != IfcConstraintEnum.USERDEFINED) or ((constraintgrade == IfcConstraintEnum.USERDEFINED) and exists(self.UserDefinedGrade)) + + + + + +class IfcConstructionEquipmentResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionEquipmentResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionMaterialResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionMaterialResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionProductResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionProductResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + + + + + + + + + + + + + +class IfcController_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcController_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccontrollertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcControllerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcControllerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcConveyorSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConveyorSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcConveyorSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcConveyorSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcconveyorsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcConveyorSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConveyorSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcConveyorSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCooledBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCooledBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccooledbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCooledBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCoolingTower_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoolingTower_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccoolingtowertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoolingTowerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTowerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + +class IfcCourse_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCourse" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCourseTypeEnum.USERDEFINED) or ((predefinedtype == IfcCourseTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCourse_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCourse" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccoursetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCourseType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCourseType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCourseTypeEnum.USERDEFINED) or ((predefinedtype == IfcCourseTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCovering_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCovering_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccoveringtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoveringType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoveringType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCrewResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcCrewResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +def calc_IfcCsgPrimitive3D_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcCurtainWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCurtainWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifccurtainwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCurtainWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcCurve_Dim(self): + + return \ + IfcCurveDim(self) + + + + + + + + + + +def calc_IfcCurveSegment_Dim(self): + parentcurve = self.ParentCurve + return \ + parentcurve.Dim + + + + +class IfcCurveStyle_IdentifiableCurveStyle: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "IdentifiableCurveStyle" + + @staticmethod + def __call__(self): + curvefont = self.CurveFont + curvewidth = self.CurveWidth + curvecolour = self.CurveColour + + assert exists(curvefont) or exists(curvewidth) or exists(curvecolour) + + + + +class IfcCurveStyle_MeasureOfWidth: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "MeasureOfWidth" + + @staticmethod + def __call__(self): + curvewidth = self.CurveWidth + + assert (not exists(curvewidth)) or ('ifc4x3.ifcpositivelengthmeasure' in typeof(curvewidth)) or (('ifc4x3.ifcdescriptivemeasure' in typeof(curvewidth)) and (curvewidth == 'bylayer')) + + + + + + + + + + + +class IfcCurveStyleFontPattern_VisibleLengthGreaterEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyleFontPattern" + RULE_NAME = "VisibleLengthGreaterEqualZero" + + @staticmethod + def __call__(self): + visiblesegmentlength = self.VisibleSegmentLength + + assert visiblesegmentlength >= 0. + + + + + + + + +class IfcDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDeepFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDeepFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcdeepfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + + + + +class IfcDerivedProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + parentprofile = self.ParentProfile + + assert self.ProfileType == parentprofile.ProfileType + + + + + +class IfcDerivedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof(elements) > 1) or ((sizeof(elements) == 1) and ((elements[1 - 1].Exponent) != 1)) + + + + +class IfcDerivedUnit_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + unittype = self.UnitType + + assert (unittype != IfcDerivedUnitEnum.USERDEFINED) or ((unittype == IfcDerivedUnitEnum.USERDEFINED) and exists(self.UserDefinedType)) + + + + +def calc_IfcDerivedUnit_Dimensions(self): + elements = self.Elements + return \ + IfcDeriveDimensionalExponents(elements) + + + + + + + + + + +class IfcDirection_MagnitudeGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcDirection" + RULE_NAME = "MagnitudeGreaterZero" + + @staticmethod + def __call__(self): + directionratios = self.DirectionRatios + + assert (sizeof([tmp for tmp in directionratios if tmp != 0.0])) > 0 + + + + +def calc_IfcDirection_Dim(self): + directionratios = self.DirectionRatios + return \ + hiindex(directionratios) + + + + +class IfcDirectrixCurveSweptAreaSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcDirectrixCurveSweptAreaSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x3.ifcconic','ifc4x3.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + + + + +class IfcDiscreteAccessory_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDiscreteAccessory_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcdiscreteaccessorytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDiscreteAccessoryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessoryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDistributionChamberElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionChamberElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcdistributionchamberelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionChamberElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDistributionSystem_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionSystem" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionSystemEnum.USERDEFINED) or ((predefinedtype == IfcDistributionSystemEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcDocumentReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDocumentReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + name = self.Name + referenceddocument = self.ReferencedDocument + + assert exists(name) ^ exists(referenceddocument) + + + + + +class IfcDoor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDoorTypeEnum.USERDEFINED) or ((predefinedtype == IfcDoorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDoor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcdoortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDoorLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcDoorLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + thresholddepth = self.ThresholdDepth + thresholdthickness = self.ThresholdThickness + + assert not exists(thresholddepth) and (not exists(thresholdthickness)) + + + + +class IfcDoorLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + transomthickness = self.TransomThickness + transomoffset = self.TransomOffset + + assert (exists(transomoffset) and exists(transomthickness)) ^ ((not exists(transomoffset)) and (not exists(transomthickness))) + + + + +class IfcDoorLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + casingthickness = self.CasingThickness + casingdepth = self.CasingDepth + + assert (exists(casingdepth) and exists(casingthickness)) ^ ((not exists(casingdepth)) and (not exists(casingthickness))) + + + + +class IfcDoorLiningProperties_WR35: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR35" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcDoorPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcDoorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDoorTypeEnum.USERDEFINED) or ((predefinedtype == IfcDoorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDraughtingPreDefinedColour_PreDefinedColourNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedColour" + RULE_NAME = "PreDefinedColourNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['black','red','green','blue','yellow','magenta','cyan','white','bylayer'] + + + + + +class IfcDraughtingPreDefinedCurveFont_PreDefinedCurveFontNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedCurveFont" + RULE_NAME = "PreDefinedCurveFontNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['continuous','chain','chaindoubledash','dashed','dotted','bylayer'] + + + + + +class IfcDuctFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcductfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcductsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSilencer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSilencer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcductsilencertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSilencerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEarthworksCut_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEarthworksCut" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEarthworksCutTypeEnum.USERDEFINED) or ((predefinedtype == IfcEarthworksCutTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcEarthworksFill_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEarthworksFill" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEarthworksFillTypeEnum.USERDEFINED) or ((predefinedtype == IfcEarthworksFillTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcEdgeLoop_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + edgelist = self.EdgeList + ne = self.Ne + + assert (edgelist[1 - 1].EdgeStart) == (edgelist[ne - 1].EdgeEnd) + + + + +class IfcEdgeLoop_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcLoopHeadToTail(self) + + + + +def calc_IfcEdgeLoop_Ne(self): + edgelist = self.EdgeList + return \ + sizeof(edgelist) + + + + +class IfcElectricAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcelectricappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcelectricdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowStorageDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowStorageDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcelectricflowstoragedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowStorageDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowTreatmentDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowTreatmentDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcelectricflowtreatmentdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowTreatmentDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricGenerator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricGenerator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcelectricgeneratortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricGeneratorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGeneratorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricMotor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricMotor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcelectricmotortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricMotorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricTimeControl_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricTimeControl_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcelectrictimecontroltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricTimeControlType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControlType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcElementAssembly_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElementAssembly_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcelementassemblytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElementAssemblyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssemblyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcElementQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcElementQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + quantities = self.Quantities + + assert IfcUniqueQuantityNames(quantities) + + + + + + + + + + + + + + + + + + + + + + + +class IfcEngine_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEngine_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcenginetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEngineType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngineType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporativeCooler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporativeCooler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcevaporativecoolertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporativeCoolerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCoolerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcevaporatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvent_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvent_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (not exists(eventtriggertype)) or (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + +class IfcEventType_CorrectEventTriggerType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectEventTriggerType" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + +class IfcEventType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + + + + + + + +class IfcExternalReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcExternalReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + location = self.Location + identification = self.Identification + name = self.Name + + assert exists(identification) or exists(location) or exists(name) + + + + + + + + + + + + + + + + + + + + + + + +class IfcExtrudedAreaSolid_ValidExtrusionDirection: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolid" + RULE_NAME = "ValidExtrusionDirection" + + @staticmethod + def __call__(self): + + + assert IfcDotProduct(IfcDirection(DirectionRatios=[0.0,0.0,1.0]),self.ExtrudedDirection) != 0.0 + + + + + +class IfcExtrudedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + +class IfcFace_HasOuterBound: + SCOPE = "entity" + TYPE_NAME = "IfcFace" + RULE_NAME = "HasOuterBound" + + @staticmethod + def __call__(self): + bounds = self.Bounds + + assert (sizeof([temp for temp in bounds if 'ifc4x3.ifcfaceouterbound' in typeof(temp)])) <= 1 + + + + + +def calc_IfcFaceBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFacilityPartCommon_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFacilityPartCommon" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFacilityPartCommonTypeEnum.USERDEFINED) or ((predefinedtype == IfcFacilityPartCommonTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcFan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFan_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcfantype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFanType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFanType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFeatureElement_NotContained: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElement" + RULE_NAME = "NotContained" + + @staticmethod + def __call__(self): + containedinstructure = self.ContainedInStructure + + assert sizeof(containedinstructure) == 0 + + + + + + + + +class IfcFeatureElementSubtraction_HasNoSubtraction: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "HasNoSubtraction" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasOpenings) == 0 + + + + +class IfcFeatureElementSubtraction_IsNotFilling: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "IsNotFilling" + + @staticmethod + def __call__(self): + + + assert sizeof(self.FillsVoids) == 0 + + + + + +class IfcFillAreaStyle_ConsistentHatchStyleDef: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "ConsistentHatchStyleDef" + + @staticmethod + def __call__(self): + + + assert IfcCorrectFillAreaStyle(self.FillStyles) + + + + +class IfcFillAreaStyle_MaxOneColour: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneColour" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x3.ifccolour' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_MaxOneExtHatchStyle: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneExtHatchStyle" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x3.ifcexternallydefinedhatchstyle' in typeof(style)])) <= 1 + + + + + +class IfcFillAreaStyleHatching_PatternStart2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "PatternStart2D" + + @staticmethod + def __call__(self): + patternstart = self.PatternStart + + assert (not exists(patternstart)) or (patternstart.Dim == 2) + + + + +class IfcFillAreaStyleHatching_RefHatchLine2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "RefHatchLine2D" + + @staticmethod + def __call__(self): + pointofreferencehatchline = self.PointOfReferenceHatchLine + + assert (not exists(pointofreferencehatchline)) or (pointofreferencehatchline.Dim == 2) + + + + + + + + +class IfcFilter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFilter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcfiltertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFilterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFireSuppressionTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFireSuppressionTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcfiresuppressionterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFireSuppressionTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + +class IfcFlowInstrument_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowInstrument_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcflowinstrumenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowInstrumentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrumentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFlowMeter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowMeter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcflowmetertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowMeterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFooting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFooting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcfootingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFootingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFootingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcFurniture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFurniture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcfurnituretype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFurnitureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurnitureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeographicElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcGeographicElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcgeographicelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcGeographicElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeometricCurveSet_NoSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricCurveSet" + RULE_NAME = "NoSurfaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Elements if 'ifc4x3.ifcsurface' in typeof(temp)])) == 0 + + + + + +class IfcGeometricRepresentationContext_North2D: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationContext" + RULE_NAME = "North2D" + + @staticmethod + def __call__(self): + truenorth = self.TrueNorth + + assert (not exists(truenorth)) or (hiindex(truenorth.DirectionRatios) == 2) + + + + + + + + +class IfcGeometricRepresentationSubContext_NoCoordOperation: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "NoCoordOperation" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasCoordinateOperation) == 0 + + + + +class IfcGeometricRepresentationSubContext_ParentNoSub: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "ParentNoSub" + + @staticmethod + def __call__(self): + parentcontext = self.ParentContext + + assert not 'ifc4x3.ifcgeometricrepresentationsubcontext' in typeof(parentcontext) + + + + +class IfcGeometricRepresentationSubContext_UserTargetProvided: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "UserTargetProvided" + + @staticmethod + def __call__(self): + targetview = self.TargetView + userdefinedtargetview = self.UserDefinedTargetView + + assert (targetview != IfcGeometricProjectionEnum.USERDEFINED) or ((targetview == IfcGeometricProjectionEnum.USERDEFINED) and exists(userdefinedtargetview)) + + + + +def calc_IfcGeometricRepresentationSubContext_WorldCoordinateSystem(self): + parentcontext = self.ParentContext + return \ + parentcontext.WorldCoordinateSystem + + + +def calc_IfcGeometricRepresentationSubContext_CoordinateSpaceDimension(self): + parentcontext = self.ParentContext + return \ + parentcontext.CoordinateSpaceDimension + + + +def calc_IfcGeometricRepresentationSubContext_TrueNorth(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.TrueNorth,IfcConvertDirectionInto2D(self.WorldCoordinateSystem.P[2 - 1])) + + + +def calc_IfcGeometricRepresentationSubContext_Precision(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.Precision,1) + + + + +class IfcGeometricSet_ConsistentDim: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricSet" + RULE_NAME = "ConsistentDim" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof([temp for temp in elements if temp.Dim != (elements[1 - 1].Dim)])) == 0 + + + + +def calc_IfcGeometricSet_Dim(self): + elements = self.Elements + return \ + elements[1 - 1].Dim + + + + + + + + + + + + + + + + +class IfcGeotechnicalStratum_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeotechnicalStratum" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcGeotechnicalStratumTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeotechnicalStratumTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +def calc_IfcGradientCurve_RelativeElevation(self): + + return \ + IfcGradient(self) + + + + + + + +class IfcGridAxis_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + axiscurve = self.AxisCurve + + assert axiscurve.Dim == 2 + + + + +class IfcGridAxis_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + partofw = self.PartOfW + partofv = self.PartOfV + partofu = self.PartOfU + + assert (sizeof(partofu) == 1) ^ (sizeof(partofv) == 1) ^ (sizeof(partofw) == 1) + + + + + + + + + + + +def calc_IfcHalfSpaceSolid_Dim(self): + + return \ + 3 + + + + +class IfcHeatExchanger_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHeatExchanger_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcheatexchangertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHeatExchangerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchangerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcHumidifier_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHumidifier_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifchumidifiertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHumidifierType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifierType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIShapeProfileDef_ValidFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFilletRadius" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + overalldepth = self.OverallDepth + webthickness = self.WebThickness + flangethickness = self.FlangeThickness + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or ((filletradius <= ((overallwidth - webthickness) / 2.)) and (filletradius <= ((overalldepth - (2. * flangethickness)) / 2.))) + + + + +class IfcIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + flangethickness = self.FlangeThickness + + assert (2. * flangethickness) < overalldepth + + + + +class IfcIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + webthickness = self.WebThickness + + assert webthickness < overallwidth + + + + + + + + +class IfcImpactProtectionDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcImpactProtectionDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcImpactProtectionDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcimpactprotectiondevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcImpactProtectionDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcImpactProtectionDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcIndexedPolyCurve_Consecutive: + SCOPE = "entity" + TYPE_NAME = "IfcIndexedPolyCurve" + RULE_NAME = "Consecutive" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (not exists(segments)) or IfcConsecutiveSegments(segments) + + + + + + + + + + + + + + + + + + + + +class IfcInterceptor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcInterceptor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcinterceptortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcInterceptorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIntersectionCurve_DistinctSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "DistinctSurfaces" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) != (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + +class IfcIntersectionCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + + + + + + + + + + + +class IfcJunctionBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcJunctionBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcjunctionboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcJunctionBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcLShapeProfileDef_ValidThickness: + SCOPE = "entity" + TYPE_NAME = "IfcLShapeProfileDef" + RULE_NAME = "ValidThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + thickness = self.Thickness + + assert (thickness < depth) and ((not exists(width)) or (thickness < width)) + + + + + +class IfcLaborResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcLaborResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +class IfcLamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifclamptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcLightFixture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLightFixture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifclightfixturetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLightFixtureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixtureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcLine_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcLine" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + pnt = self.Pnt + dir = self.Dir + + assert dir.Dim == pnt.Dim + + + + + + + + + + + + + + +class IfcLiquidTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLiquidTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcLiquidTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLiquidTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcliquidterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLiquidTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLiquidTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcLiquidTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcLocalPlacement_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcLocalPlacement" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + placementrelto = self.PlacementRelTo + relativeplacement = self.RelativePlacement + + assert IfcCorrectLocalPlacement(relativeplacement,placementrelto) + + + + + + + + + + + + + + + + + +class IfcMarineFacility_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMarineFacility" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMarineFacilityTypeEnum.USERDEFINED) or ((predefinedtype == IfcMarineFacilityTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcMarinePart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMarinePart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMarinePartTypeEnum.USERDEFINED) or ((predefinedtype == IfcMarinePartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + + + + + + + + + + +class IfcMaterialDefinitionRepresentation_OnlyStyledRepresentations: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialDefinitionRepresentation" + RULE_NAME = "OnlyStyledRepresentations" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x3.ifcstyledrepresentation' in typeof(temp)])) == 0 + + + + + +class IfcMaterialLayer_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialLayer" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + +def calc_IfcMaterialLayerSet_TotalThickness(self): + + return \ + IfcMlsTotalThickness(self) + + + + + + + + + + + + + +class IfcMaterialProfile_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialProfile" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMechanicalFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMechanicalFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcmechanicalfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMechanicalFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMedicalDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMedicalDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcmedicaldevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMedicalDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMember_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMember_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcmembertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMemberType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMemberType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcMirroredProfileDef_Operator(self): + + return \ + IfcCartesianTransformationOperator2D(Axis1=IfcDirection(DirectionRatios=[-1.,0.]), Axis2=IfcDirection(DirectionRatios=[0.,1.]), LocalOrigin=IfcCartesianPoint(Coordinates=[0.,0.]), Scale=1.) + + + + +class IfcMobileTelecommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMobileTelecommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcmobiletelecommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMobileTelecommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcMooringDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMooringDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMooringDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMooringDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcmooringdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMooringDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMooringDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMooringDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMotorConnection_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMotorConnection_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcmotorconnectiontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMotorConnectionType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnectionType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcNamedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcNamedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert IfcCorrectDimensions(self.UnitType,self.Dimensions) + + + + + +class IfcNavigationElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcNavigationElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcNavigationElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcNavigationElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcnavigationelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcNavigationElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcNavigationElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcNavigationElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + isdefinedby = self.IsDefinedBy + + assert (sizeof(isdefinedby) == 0) or IfcUniqueDefinitionNames(isdefinedby) + + + + + + + + + + + +class IfcObjective_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcObjective" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + objectivequalifier = self.ObjectiveQualifier + + assert (objectivequalifier != IfcObjectiveEnum.USERDEFINED) or ((objectivequalifier == IfcObjectiveEnum.USERDEFINED) and exists(self.UserDefinedQualifier)) + + + + + +class IfcOccupant_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcOccupant" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not predefinedtype == IfcOccupantTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcOffsetCurve2D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve2D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 2 + + + + + +class IfcOffsetCurve3D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve3D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 3 + + + + + + + + +class IfcOpenCrossProfileDef_CorrectProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrectProfileType" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == IfcProfileTypeEnum.CURVE + + + + +class IfcOpenCrossProfileDef_CorrespondingSlopeWidths: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrespondingSlopeWidths" + + @staticmethod + def __call__(self): + widths = self.Widths + slopes = self.Slopes + + assert sizeof(slopes) == sizeof(widths) + + + + +class IfcOpenCrossProfileDef_CorrespondingTags: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrespondingTags" + + @staticmethod + def __call__(self): + slopes = self.Slopes + tags = self.Tags + + assert (not exists(tags)) or (sizeof(tags) == (sizeof(slopes) + 1)) + + + + + + + + +class IfcOpeningElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOpeningElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcOpeningElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcOpeningElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcOrientedEdge_EdgeElementNotOriented: + SCOPE = "entity" + TYPE_NAME = "IfcOrientedEdge" + RULE_NAME = "EdgeElementNotOriented" + + @staticmethod + def __call__(self): + edgeelement = self.EdgeElement + + assert not 'ifc4x3.ifcorientededge' in typeof(edgeelement) + + + + +def calc_IfcOrientedEdge_EdgeStart(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeStart,edgeelement.EdgeEnd) + + + +def calc_IfcOrientedEdge_EdgeEnd(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeEnd,edgeelement.EdgeStart) + + + + + + + +class IfcOutlet_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcOutlet_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcoutlettype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcOutletType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutletType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcOwnerHistory_CorrectChangeAction: + SCOPE = "entity" + TYPE_NAME = "IfcOwnerHistory" + RULE_NAME = "CorrectChangeAction" + + @staticmethod + def __call__(self): + changeaction = self.ChangeAction + lastmodifieddate = self.LastModifiedDate + + assert exists(lastmodifieddate) or ((not exists(lastmodifieddate)) and (not exists(changeaction))) or ((not exists(lastmodifieddate)) and exists(changeaction) and ((changeaction == IfcChangeActionEnum.NOTDEFINED) or (changeaction == IfcChangeActionEnum.NOCHANGE))) + + + + + + + + +class IfcPath_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcPath" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcPathHeadToTail(self) + + + + + +class IfcPavement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPavement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPavementTypeEnum.USERDEFINED) or ((predefinedtype == IfcPavementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPavement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPavement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcpavementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPavementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPavementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPavementTypeEnum.USERDEFINED) or ((predefinedtype == IfcPavementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPcurve_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcPcurve" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + referencecurve = self.ReferenceCurve + + assert referencecurve.Dim == 2 + + + + + + + + + + + + + + +class IfcPerson_IdentifiablePerson: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "IdentifiablePerson" + + @staticmethod + def __call__(self): + identification = self.Identification + familyname = self.FamilyName + givenname = self.GivenName + + assert exists(identification) or exists(familyname) or exists(givenname) + + + + +class IfcPerson_ValidSetOfNames: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "ValidSetOfNames" + + @staticmethod + def __call__(self): + familyname = self.FamilyName + givenname = self.GivenName + middlenames = self.MiddleNames + + assert (not exists(middlenames)) or exists(familyname) or exists(givenname) + + + + + + + + +class IfcPhysicalComplexQuantity_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert (sizeof([temp for temp in hasquantities if self == temp])) == 0 + + + + +class IfcPhysicalComplexQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert IfcUniqueQuantityNames(hasquantities) + + + + + + + + + + + +class IfcPile_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPile_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcpiletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPileType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPileType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcpipefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcpipesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPixelTexture_MinPixelInS: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInS" + + @staticmethod + def __call__(self): + width = self.Width + + assert width >= 1 + + + + +class IfcPixelTexture_MinPixelInT: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInT" + + @staticmethod + def __call__(self): + height = self.Height + + assert height >= 1 + + + + +class IfcPixelTexture_NumberOfColours: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "NumberOfColours" + + @staticmethod + def __call__(self): + colourcomponents = self.ColourComponents + + assert 1 <= colourcomponents <= 4 + + + + +class IfcPixelTexture_PixelAsByteAndSameLength: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "PixelAsByteAndSameLength" + + @staticmethod + def __call__(self): + pixel = self.Pixel + + assert (sizeof([temp for temp in pixel if ((blength(temp) % 8) == 0) and (blength(temp) == (blength(pixel[1 - 1])))])) == sizeof(pixel) + + + + +class IfcPixelTexture_SizeOfPixelList: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "SizeOfPixelList" + + @staticmethod + def __call__(self): + width = self.Width + height = self.Height + pixel = self.Pixel + + assert sizeof(pixel) == (width * height) + + + + + +def calc_IfcPlacement_Dim(self): + location = self.Location + return \ + location.Dim + + + + + + + + + + + + + +class IfcPlate_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPlate_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcplatetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPlateType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlateType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcPointByDistanceExpression_Dim(self): + basiscurve = self.BasisCurve + return \ + basiscurve.Dim + + + + +def calc_IfcPointOnCurve_Dim(self): + basiscurve = self.BasisCurve + return \ + basiscurve.Dim + + + + +def calc_IfcPointOnSurface_Dim(self): + basissurface = self.BasisSurface + return \ + basissurface.Dim + + + + +class IfcPolyLoop_AllPointsSameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyLoop" + RULE_NAME = "AllPointsSameDim" + + @staticmethod + def __call__(self): + polygon = self.Polygon + + assert (sizeof([temp for temp in polygon if temp.Dim != (polygon[1 - 1].Dim)])) == 0 + + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryDim" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert polygonalboundary.Dim == 2 + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryType: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryType" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert (sizeof(typeof(polygonalboundary) * ['ifc4x3.ifcpolyline','ifc4x3.ifccompositecurve','ifc4x3.ifcindexedpolycurve'])) == 1 + + + + + + + + +class IfcPolyline_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyline" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + points = self.Points + + assert (sizeof([temp for temp in points if temp.Dim != (points[1 - 1].Dim)])) == 0 + + + + + +class IfcPolynomialCurve_CorrectPositionDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolynomialCurve" + RULE_NAME = "CorrectPositionDim" + + @staticmethod + def __call__(self): + position = self.Position + coefficientsz = self.CoefficientsZ + + assert ((position.Dim == 2) and (not exists(coefficientsz))) or (position.Dim == 3) + + + + +class IfcPolynomialCurve_ValidCoefficients: + SCOPE = "entity" + TYPE_NAME = "IfcPolynomialCurve" + RULE_NAME = "ValidCoefficients" + + @staticmethod + def __call__(self): + coefficientsx = self.CoefficientsX + coefficientsy = self.CoefficientsY + coefficientsz = self.CoefficientsZ + + assert (exists(coefficientsx) and exists(coefficientsy)) or (exists(coefficientsx) and exists(coefficientsz)) or (exists(coefficientsy) and exists(coefficientsz)) or (exists(coefficientsx) and exists(coefficientsy) and exists(coefficientsz)) + + + + + + + + +class IfcPositioningElement_HasPlacement: + SCOPE = "entity" + TYPE_NAME = "IfcPositioningElement" + RULE_NAME = "HasPlacement" + + @staticmethod + def __call__(self): + + + assert exists(self.ObjectPlacement) + + + + + +class IfcPostalAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPostalAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + internallocation = self.InternalLocation + addresslines = self.AddressLines + postalbox = self.PostalBox + town = self.Town + region = self.Region + postalcode = self.PostalCode + country = self.Country + + assert exists(internallocation) or exists(addresslines) or exists(postalbox) or exists(postalcode) or exists(town) or exists(region) or exists(country) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPresentationLayerAssignment_ApplicableItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerAssignment" + RULE_NAME = "ApplicableItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x3.ifcshaperepresentation','ifc4x3.ifcgeometricrepresentationitem','ifc4x3.ifcmappeditem'])) == 1])) == sizeof(assigneditems) + + + + + +class IfcPresentationLayerWithStyle_ApplicableOnlyToItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerWithStyle" + RULE_NAME = "ApplicableOnlyToItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x3.ifcgeometricrepresentationitem','ifc4x3.ifcmappeditem'])) >= 1])) == sizeof(assigneditems) + + + + + + + + +class IfcProcedure_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProcedure_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcProcedureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + + + + +class IfcProduct_PlacementForShapeRepresentation: + SCOPE = "entity" + TYPE_NAME = "IfcProduct" + RULE_NAME = "PlacementForShapeRepresentation" + + @staticmethod + def __call__(self): + objectplacement = self.ObjectPlacement + representation = self.Representation + + assert (exists(representation) and exists(objectplacement)) or (exists(representation) and ((sizeof([temp for temp in representation.Representations if 'ifc4x3.ifcshaperepresentation' in typeof(temp)])) == 0)) or (not exists(representation)) + + + + + +class IfcProductDefinitionShape_OnlyShapeModel: + SCOPE = "entity" + TYPE_NAME = "IfcProductDefinitionShape" + RULE_NAME = "OnlyShapeModel" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x3.ifcshapemodel' in typeof(temp)])) == 0 + + + + + + + + + + + + + + +class IfcProject_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert (not exists(self.RepresentationContexts)) or ((sizeof([temp for temp in self.RepresentationContexts if 'ifc4x3.ifcgeometricrepresentationsubcontext' in typeof(temp)])) == 0) + + + + +class IfcProject_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProject_NoDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "NoDecomposition" + + @staticmethod + def __call__(self): + + + assert sizeof(self.Decomposes) == 0 + + + + + + + + + + + +class IfcProjectedCRS_IsLengthUnit: + SCOPE = "entity" + TYPE_NAME = "IfcProjectedCRS" + RULE_NAME = "IsLengthUnit" + + @staticmethod + def __call__(self): + mapunit = self.MapUnit + + assert (not exists(mapunit)) or (mapunit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + + +class IfcProjectionElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProjectionElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProjectionElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcProjectionElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcPropertyBoundedValue_SameUnitLowerSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitLowerSet" + + @staticmethod + def __call__(self): + lowerboundvalue = self.LowerBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(lowerboundvalue)) or (not exists(setpointvalue)) or (typeof(lowerboundvalue) == typeof(setpointvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitUpperLower: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperLower" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + lowerboundvalue = self.LowerBoundValue + + assert (not exists(upperboundvalue)) or (not exists(lowerboundvalue)) or (typeof(upperboundvalue) == typeof(lowerboundvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitUpperSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperSet" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(upperboundvalue)) or (not exists(setpointvalue)) or (typeof(upperboundvalue) == typeof(setpointvalue)) + + + + + + + + +class IfcPropertyDependencyRelationship_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyDependencyRelationship" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + dependingproperty = self.DependingProperty + dependantproperty = self.DependantProperty + + assert dependingproperty != dependantproperty + + + + + +class IfcPropertyEnumeratedValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeratedValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + enumerationvalues = self.EnumerationValues + enumerationreference = self.EnumerationReference + + assert (not exists(enumerationreference)) or (not exists(enumerationvalues)) or ((sizeof([temp for temp in enumerationvalues if temp in enumerationreference.EnumerationValues])) == sizeof(enumerationvalues)) + + + + + +class IfcPropertyEnumeration_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeration" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.EnumerationValues if not (typeof(self.EnumerationValues[1 - 1])) == typeof(temp)])) == 0 + + + + + +class IfcPropertyListValue_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyListValue" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.ListValues if not (typeof(self.ListValues[1 - 1])) == typeof(temp)])) == 0 + + + + + + + + +class IfcPropertySet_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySet_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + + + + +class IfcPropertySetTemplate_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySetTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + + + + + +class IfcPropertyTableValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + definedvalues = self.DefinedValues + + assert ((not exists(definingvalues)) and (not exists(definedvalues))) or (sizeof(definingvalues) == sizeof(definedvalues)) + + + + +class IfcPropertyTableValue_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + + assert (not exists(definingvalues)) or ((sizeof([temp for temp in self.DefiningValues if typeof(temp) != (typeof(self.DefiningValues[1 - 1]))])) == 0) + + + + +class IfcPropertyTableValue_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + definedvalues = self.DefinedValues + + assert (not exists(definedvalues)) or ((sizeof([temp for temp in self.DefinedValues if typeof(temp) != (typeof(self.DefinedValues[1 - 1]))])) == 0) + + + + + + + + + + + +class IfcProtectiveDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcprotectivedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcprotectivedevicetrippingunittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProtectiveDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPump_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPump_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcpumptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPumpType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPumpType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcQuantityArea_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.AREAUNIT) + + + + +class IfcQuantityArea_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + areavalue = self.AreaValue + + assert areavalue >= 0. + + + + + +class IfcQuantityCount_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityCount" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + countvalue = self.CountValue + + assert countvalue >= 0 + + + + + +class IfcQuantityLength_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + +class IfcQuantityLength_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + lengthvalue = self.LengthValue + + assert lengthvalue >= 0. + + + + + + + + + + + +class IfcQuantityTime_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.TIMEUNIT) + + + + +class IfcQuantityTime_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + timevalue = self.TimeValue + + assert timevalue >= 0. + + + + + +class IfcQuantityVolume_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.VOLUMEUNIT) + + + + +class IfcQuantityVolume_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + volumevalue = self.VolumeValue + + assert volumevalue >= 0. + + + + + +class IfcQuantityWeight_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.MASSUNIT) + + + + +class IfcQuantityWeight_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + weightvalue = self.WeightValue + + assert weightvalue >= 0. + + + + + +class IfcRail_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRail" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRail_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRail" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcrailtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRailing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRailing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcrailingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRailway_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailway" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailwayTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailwayTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRailway_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcRailway" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailwayTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcRailwayPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailwayPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailwayPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailwayPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcRamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcramptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRampFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcrampflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRationalBSplineCurveWithKnots_SameNumOfWeightsAndPoints: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "SameNumOfWeightsAndPoints" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert sizeof(weightsdata) == sizeof(self.ControlPointsList) + + + + +class IfcRationalBSplineCurveWithKnots_WeightsGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "WeightsGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcCurveWeightsPositive(self) + + + + +def calc_IfcRationalBSplineCurveWithKnots_Weights(self): + weightsdata = self.WeightsData + return \ + IfcListToArray(weightsdata,0,self.UpperIndexOnControlPoints) + + + + +class IfcRationalBSplineSurfaceWithKnots_CorrespondingWeightsDataLists: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingWeightsDataLists" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert (sizeof(weightsdata) == sizeof(self.ControlPointsList)) and ((sizeof(weightsdata[1 - 1])) == (sizeof(self.ControlPointsList[1 - 1]))) + + + + +class IfcRationalBSplineSurfaceWithKnots_WeightValuesGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "WeightValuesGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcSurfaceWeightsPositive(self) + + + + +def calc_IfcRationalBSplineSurfaceWithKnots_Weights(self): + uupper = self.UUpper + vupper = self.VUpper + weightsdata = self.WeightsData + return \ + IfcMakeArrayOfArray(weightsdata,0,uupper,0,vupper) + + + + +class IfcRectangleHollowProfileDef_ValidInnerRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidInnerRadius" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + innerfilletradius = self.InnerFilletRadius + + assert (not exists(innerfilletradius)) or ((innerfilletradius <= ((self.XDim / 2.) - wallthickness)) and (innerfilletradius <= ((self.YDim / 2.) - wallthickness))) + + + + +class IfcRectangleHollowProfileDef_ValidOuterRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidOuterRadius" + + @staticmethod + def __call__(self): + outerfilletradius = self.OuterFilletRadius + + assert (not exists(outerfilletradius)) or ((outerfilletradius <= (self.XDim / 2.)) and (outerfilletradius <= (self.YDim / 2.))) + + + + +class IfcRectangleHollowProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert (wallthickness < (self.XDim / 2.)) and (wallthickness < (self.YDim / 2.)) + + + + + + + + + + + +class IfcRectangularTrimmedSurface_U1AndU2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "U1AndU2Different" + + @staticmethod + def __call__(self): + u1 = self.U1 + u2 = self.U2 + + assert u1 != u2 + + + + +class IfcRectangularTrimmedSurface_UsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "UsenseCompatible" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + u1 = self.U1 + u2 = self.U2 + usense = self.Usense + + assert (('ifc4x3.ifcelementarysurface' in typeof(basissurface)) and (not 'ifc4x3.ifcplane' in typeof(basissurface))) or ('ifc4x3.ifcsurfaceofrevolution' in typeof(basissurface)) or (usense == (u2 > u1)) + + + + +class IfcRectangularTrimmedSurface_V1AndV2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "V1AndV2Different" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + + assert v1 != v2 + + + + +class IfcRectangularTrimmedSurface_VsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "VsenseCompatible" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + vsense = self.Vsense + + assert vsense == (v2 > v1) + + + + + + + + + + + + + + + + + +class IfcReinforcedSoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcedSoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcedSoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcedSoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcReinforcingBar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingBar_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcreinforcingbartype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingBarType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + +class IfcReinforcingBarType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcReinforcingMesh_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingMesh_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcreinforcingmeshtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingMeshType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + +class IfcReinforcingMeshType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcRelAggregates_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAggregates" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelAssigns_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssigns" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatedobjects = self.RelatedObjects + relatedobjectstype = self.RelatedObjectsType + + assert IfcCorrectObjectAssignment(relatedobjectstype,relatedobjects) + + + + + +class IfcRelAssignsToActor_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToActor" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingactor = self.RelatingActor + + assert (sizeof([temp for temp in self.RelatedObjects if relatingactor == temp])) == 0 + + + + + +class IfcRelAssignsToControl_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToControl" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontrol = self.RelatingControl + + assert (sizeof([temp for temp in self.RelatedObjects if relatingcontrol == temp])) == 0 + + + + + +class IfcRelAssignsToGroup_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToGroup" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatinggroup = self.RelatingGroup + + assert (sizeof([temp for temp in self.RelatedObjects if relatinggroup == temp])) == 0 + + + + + + + + +class IfcRelAssignsToProcess_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProcess" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + + assert (sizeof([temp for temp in self.RelatedObjects if relatingprocess == temp])) == 0 + + + + + +class IfcRelAssignsToProduct_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProduct" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingproduct = self.RelatingProduct + + assert (sizeof([temp for temp in self.RelatedObjects if relatingproduct == temp])) == 0 + + + + + +class IfcRelAssignsToResource_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToResource" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingresource = self.RelatingResource + + assert (sizeof([temp for temp in self.RelatedObjects if relatingresource == temp])) == 0 + + + + + + + + + + + + + + + + + + + + + + + +class IfcRelAssociatesMaterial_AllowedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "AllowedElements" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if (sizeof(typeof(temp) * ['ifc4x3.ifcelement','ifc4x3.ifcelementtype','ifc4x3.ifcwindowstyle','ifc4x3.ifcdoorstyle','ifc4x3.ifcstructuralmember','ifc4x3.ifcport'])) == 0])) == 0 + + + + +class IfcRelAssociatesMaterial_NoVoidElement: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "NoVoidElement" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if ('ifc4x3.ifcfeatureelementsubtraction' in typeof(temp)) or ('ifc4x3.ifcvirtualelement' in typeof(temp))])) == 0 + + + + + + + + + + + +class IfcRelConnectsElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelConnectsPathElements_NormalizedRelatedPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatedPriorities" + + @staticmethod + def __call__(self): + relatedpriorities = self.RelatedPriorities + + assert (sizeof(relatedpriorities) == 0) or ((sizeof([temp for temp in relatedpriorities if 0 <= temp <= 100])) == sizeof(relatedpriorities)) + + + + +class IfcRelConnectsPathElements_NormalizedRelatingPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatingPriorities" + + @staticmethod + def __call__(self): + relatingpriorities = self.RelatingPriorities + + assert (sizeof(relatingpriorities) == 0) or ((sizeof([temp for temp in relatingpriorities if 0 <= temp <= 100])) == sizeof(relatingpriorities)) + + + + + + + + +class IfcRelConnectsPorts_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPorts" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingport = self.RelatingPort + relatedport = self.RelatedPort + + assert relatingport != relatedport + + + + + + + + + + + + + + + + + +class IfcRelContainedInSpatialStructure_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRelContainedInSpatialStructure" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if 'ifc4x3.ifcspatialstructureelement' in typeof(temp)])) == 0 + + + + + + + + + + + +class IfcRelDeclares_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelDeclares" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontext = self.RelatingContext + relateddefinitions = self.RelatedDefinitions + + assert (sizeof([temp for temp in relateddefinitions if relatingcontext == temp])) == 0 + + + + + + + + + + + + + + +class IfcRelDefinesByProperties_NoRelatedTypeObject: + SCOPE = "entity" + TYPE_NAME = "IfcRelDefinesByProperties" + RULE_NAME = "NoRelatedTypeObject" + + @staticmethod + def __call__(self): + + + assert (sizeof([types for types in self.RelatedObjects if 'ifc4x3.ifctypeobject' in typeof(types)])) == 0 + + + + + + + + + + + + + + + + + +class IfcRelInterferesElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelInterferesElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelNests_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelNests" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelPositions_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelPositions" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingpositioningelement = self.RelatingPositioningElement + relatedproducts = self.RelatedProducts + + assert (sizeof([temp for temp in relatedproducts if relatingpositioningelement == temp])) == 0 + + + + + + + + +class IfcRelReferencedInSpatialStructure_AllowedRelatedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelReferencedInSpatialStructure" + RULE_NAME = "AllowedRelatedElements" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if ('ifc4x3.ifcspatialstructureelement' in typeof(temp)) and (not 'ifc4x3.ifcspace' in typeof(temp))])) == 0 + + + + + +class IfcRelSequence_AvoidInconsistentSequence: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "AvoidInconsistentSequence" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + relatedprocess = self.RelatedProcess + + assert relatingprocess != relatedprocess + + + + +class IfcRelSequence_CorrectSequenceType: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "CorrectSequenceType" + + @staticmethod + def __call__(self): + sequencetype = self.SequenceType + userdefinedsequencetype = self.UserDefinedSequenceType + + assert (sequencetype != IfcSequenceEnum.USERDEFINED) or ((sequencetype == IfcSequenceEnum.USERDEFINED) and exists(userdefinedsequencetype)) + + + + + + + + +class IfcRelSpaceBoundary_CorrectPhysOrVirt: + SCOPE = "entity" + TYPE_NAME = "IfcRelSpaceBoundary" + RULE_NAME = "CorrectPhysOrVirt" + + @staticmethod + def __call__(self): + relatedbuildingelement = self.RelatedBuildingElement + physicalorvirtualboundary = self.PhysicalOrVirtualBoundary + + assert ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Physical) and (not 'ifc4x3.ifcvirtualelement' in typeof(relatedbuildingelement))) or ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Virtual) and (('ifc4x3.ifcvirtualelement' in typeof(relatedbuildingelement)) or ('ifc4x3.ifcopeningelement' in typeof(relatedbuildingelement)))) or (physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.NotDefined) + + + + + + + + + + + + + + + + + +class IfcReparametrisedCompositeCurveSegment_PositiveLengthParameter: + SCOPE = "entity" + TYPE_NAME = "IfcReparametrisedCompositeCurveSegment" + RULE_NAME = "PositiveLengthParameter" + + @staticmethod + def __call__(self): + paramlength = self.ParamLength + + assert paramlength > 0.0 + + + + + + + + + + + + + + +class IfcRepresentationMap_ApplicableMappedRepr: + SCOPE = "entity" + TYPE_NAME = "IfcRepresentationMap" + RULE_NAME = "ApplicableMappedRepr" + + @staticmethod + def __call__(self): + mappedrepresentation = self.MappedRepresentation + + assert 'ifc4x3.ifcshapemodel' in typeof(mappedrepresentation) + + + + + + + + + + + + + + + + + + + + +class IfcRevolvedAreaSolid_AxisDirectionInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisDirectionInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Z.DirectionRatios[3 - 1]) == 0.0 + + + + +class IfcRevolvedAreaSolid_AxisStartInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisStartInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Location.Coordinates[3 - 1]) == 0.0 + + + + +def calc_IfcRevolvedAreaSolid_AxisLine(self): + axis = self.Axis + return \ + IfcLine(Pnt=axis.Location, Dir=IfcVector(Orientation=axis.Z, Magnitude=1.0)) + + + + +class IfcRevolvedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + + + + + + + +class IfcRoad_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoad" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoadTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoadTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRoad_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcRoad" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoadTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcRoadPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoadPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoadPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoadPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcRoof_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRoof_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcrooftype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRoofType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoofType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcRoundedRectangleProfileDef_ValidRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRoundedRectangleProfileDef" + RULE_NAME = "ValidRadius" + + @staticmethod + def __call__(self): + roundingradius = self.RoundingRadius + + assert (roundingradius <= (self.XDim / 2.)) and (roundingradius <= (self.YDim / 2.)) + + + + + +def calc_IfcSIUnit_Dimensions(self): + + return \ + IfcDimensionsForSIUnit(self.Name) + + + + +class IfcSanitaryTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSanitaryTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcsanitaryterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSanitaryTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSeamCurve_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) == (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + +class IfcSeamCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + + + + + + + + + + + +class IfcSectionedSolid_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSolid_DirectrixIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "DirectrixIs3D" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSectionedSolid_SectionsSameType: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "SectionsSameType" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (typeof(crosssections[1 - 1])) != typeof(temp)])) == 0 + + + + + +class IfcSectionedSolidHorizontal_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSolidHorizontal_NoLongitudinalOffsets: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "NoLongitudinalOffsets" + + @staticmethod + def __call__(self): + crosssectionpositions = self.CrossSectionPositions + + assert (sizeof([temp for temp in crosssectionpositions if exists(temp.Location.OffsetLongitudinal)])) == 0 + + + + + +class IfcSectionedSpine_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSpine_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSpine_SpineCurveDim: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "SpineCurveDim" + + @staticmethod + def __call__(self): + spinecurve = self.SpineCurve + + assert spinecurve.Dim == 3 + + + + +def calc_IfcSectionedSpine_Dim(self): + + return \ + 3 + + + + +class IfcSectionedSurface_AreaProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSurface" + RULE_NAME = "AreaProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if temp.ProfileType == IfcProfileTypeEnum.CURVE])) == 0 + + + + +class IfcSectionedSurface_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSurface" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssectionpositions = self.CrossSectionPositions + crosssections = self.CrossSections + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSurface_DirectrixIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSurface" + RULE_NAME = "DirectrixIs3D" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSectionedSurface_NoOffsets: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSurface" + RULE_NAME = "NoOffsets" + + @staticmethod + def __call__(self): + crosssectionpositions = self.CrossSectionPositions + + assert (sizeof([temp for temp in crosssectionpositions if exists(temp.Location.OffsetLateral) or exists(temp.Location.OffsetVertical) or exists(temp.Location.OffsetLongitudinal)])) == 0 + + + + +class IfcSectionedSurface_SectionsSameType: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSurface" + RULE_NAME = "SectionsSameType" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (typeof(crosssections[1 - 1])) != typeof(temp)])) == 0 + + + + + + + + + + + +class IfcSensor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSensor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcsensortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSensorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcShadingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcShadingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcshadingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcShadingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcShapeModel_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcShapeModel" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + ofshapeaspect = self.OfShapeAspect + + assert (sizeof(self.OfProductRepresentation) == 1) ^ (sizeof(self.RepresentationMap) == 1) ^ (sizeof(ofshapeaspect) == 1) + + + + + +class IfcShapeRepresentation_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3.ifcgeometricrepresentationcontext' in typeof(self.ContextOfItems) + + + + +class IfcShapeRepresentation_CorrectItemsForType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectItemsForType" + + @staticmethod + def __call__(self): + + + assert IfcShapeRepresentationTypes(self.RepresentationType,self.Items) + + + + +class IfcShapeRepresentation_HasRepresentationIdentifier: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationIdentifier" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationIdentifier) + + + + +class IfcShapeRepresentation_HasRepresentationType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationType" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcShapeRepresentation_NoTopologicalItem: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "NoTopologicalItem" + + @staticmethod + def __call__(self): + items = self.Items + + assert (sizeof([temp for temp in items if ('ifc4x3.ifctopologicalrepresentationitem' in typeof(temp)) and (not (sizeof(['ifc4x3.ifcvertexpoint','ifc4x3.ifcedgecurve','ifc4x3.ifcfacesurface'] * typeof(temp))) == 1)])) == 0 + + + + + +def calc_IfcShellBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + +class IfcSign_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSign" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSignTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSign_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSign" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcsigntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSignType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSignTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSignal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSignalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSignal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSignal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcsignaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSignalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSignalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + +class IfcSlab_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSlab_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcslabtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSlabType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlabType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSolarDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSolarDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcsolardevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSolarDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcSolidModel_Dim(self): + + return \ + 3 + + + + +class IfcSpace_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpace_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcspacetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeater_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpaceHeater_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcspaceheatertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeaterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeaterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSpaceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcSpatialStructureElement_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialStructureElement" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + + + assert (hiindex(self.Decomposes) == 1) and ('ifc4x3.ifcrelaggregates' in (typeof(self.Decomposes[1 - 1]))) and (('ifc4x3.ifcproject' in (typeof(self.Decomposes[1 - 1].RelatingObject))) or ('ifc4x3.ifcspatialstructureelement' in (typeof(self.Decomposes[1 - 1].RelatingObject)))) + + + + + + + + +class IfcSpatialZone_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpatialZone_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcspatialzonetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpatialZoneType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZoneType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcStackTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStackTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcstackterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStackTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStair_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStair_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcstairtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStairFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcstairflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStairType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcStructuralAnalysisModel_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralAnalysisModel" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAnalysisModelTypeEnum.USERDEFINED) or ((predefinedtype == IfcAnalysisModelTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStructuralAnalysisModel_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralAnalysisModel" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAnalysisModelTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + + + + +class IfcStructuralCurveAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralCurveAction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert predefinedtype != IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + + + + + + + +class IfcStructuralCurveMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralCurveReaction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveReaction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.SINUS) and (predefinedtype != IfcStructuralCurveActivityTypeEnum.PARABOLA) + + + + + + + + +class IfcStructuralLinearAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralCurveActivityTypeEnum.CONST + + + + +class IfcStructuralLinearAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3.ifcstructuralloadlinearforce','ifc4x3.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralLoadCase_IsLoadCasePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadCase" + RULE_NAME = "IsLoadCasePredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcLoadGroupTypeEnum.LOAD_CASE + + + + + +class IfcStructuralLoadConfiguration_ValidListSize: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadConfiguration" + RULE_NAME = "ValidListSize" + + @staticmethod + def __call__(self): + values = self.Values + locations = self.Locations + + assert (not exists(locations)) or (sizeof(locations) == sizeof(values)) + + + + + +class IfcStructuralLoadGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + actiontype = self.ActionType + actionsource = self.ActionSource + + assert ((predefinedtype != IfcLoadGroupTypeEnum.USERDEFINED) and (actiontype != IfcActionTypeEnum.USERDEFINED) and (actionsource != IfcActionSourceTypeEnum.USERDEFINED)) or exists(self.ObjectType) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcStructuralPlanarAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralSurfaceActivityTypeEnum.CONST + + + + +class IfcStructuralPlanarAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3.ifcstructuralloadplanarforce','ifc4x3.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + + +class IfcStructuralPointAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3.ifcstructuralloadsingleforce','ifc4x3.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralPointReaction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointReaction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3.ifcstructuralloadsingleforce','ifc4x3.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralResultGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralResultGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + theorytype = self.TheoryType + + assert (theorytype != IfcAnalysisTheoryTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcStructuralSurfaceAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralSurfaceAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + + + + + +class IfcStructuralSurfaceMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceReaction_HasPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceReaction" + RULE_NAME = "HasPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStyledItem_ApplicableItem: + SCOPE = "entity" + TYPE_NAME = "IfcStyledItem" + RULE_NAME = "ApplicableItem" + + @staticmethod + def __call__(self): + item = self.Item + + assert not 'ifc4x3.ifcstyleditem' in typeof(item) + + + + + +class IfcStyledRepresentation_OnlyStyledItems: + SCOPE = "entity" + TYPE_NAME = "IfcStyledRepresentation" + RULE_NAME = "OnlyStyledItems" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x3.ifcstyleditem' in typeof(temp)])) == 0 + + + + + +class IfcSubContractResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcSubContractResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +def calc_IfcSurface_Dim(self): + + return \ + 3 + + + + +class IfcSurfaceCurve_CurveIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIs3D" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert curve3d.Dim == 3 + + + + +class IfcSurfaceCurve_CurveIsNotPcurve: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIsNotPcurve" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert not 'ifc4x3.ifcpcurve' in typeof(curve3d) + + + + +def calc_IfcSurfaceCurve_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + + + + +class IfcSurfaceFeature_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceFeature" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSurfaceFeatureTypeEnum.USERDEFINED) or ((predefinedtype == IfcSurfaceFeatureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSurfaceFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSurfaceFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcSurfaceOfLinearExtrusion_DepthGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceOfLinearExtrusion" + RULE_NAME = "DepthGreaterZero" + + @staticmethod + def __call__(self): + depth = self.Depth + + assert depth > 0. + + + + +def calc_IfcSurfaceOfLinearExtrusion_ExtrusionAxis(self): + extrudeddirection = self.ExtrudedDirection + depth = self.Depth + return \ + IfcVector(Orientation=extrudeddirection, Magnitude=depth) + + + + +def calc_IfcSurfaceOfRevolution_AxisLine(self): + axisposition = self.AxisPosition + return \ + IfcLine(Pnt=axisposition.Location, Dir=IfcVector(Orientation=axisposition.Z, Magnitude=1.0)) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea1: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea1" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + + assert (not exists(surfacereinforcement1)) or (((surfacereinforcement1[1 - 1]) >= 0.) and ((surfacereinforcement1[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement1) == 1) or ((surfacereinforcement1[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea2: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea2" + + @staticmethod + def __call__(self): + surfacereinforcement2 = self.SurfaceReinforcement2 + + assert (not exists(surfacereinforcement2)) or (((surfacereinforcement2[1 - 1]) >= 0.) and ((surfacereinforcement2[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement2) == 1) or ((surfacereinforcement2[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea3: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea3" + + @staticmethod + def __call__(self): + shearreinforcement = self.ShearReinforcement + + assert (not exists(shearreinforcement)) or (shearreinforcement >= 0.) + + + + +class IfcSurfaceReinforcementArea_SurfaceAndOrShearAreaSpecified: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "SurfaceAndOrShearAreaSpecified" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + surfacereinforcement2 = self.SurfaceReinforcement2 + shearreinforcement = self.ShearReinforcement + + assert exists(surfacereinforcement1) or exists(surfacereinforcement2) or exists(shearreinforcement) + + + + + +class IfcSurfaceStyle_MaxOneExtDefined: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneExtDefined" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3.ifcexternallydefinedsurfacestyle' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneLighting: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneLighting" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3.ifcsurfacestylelighting' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneRefraction: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneRefraction" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3.ifcsurfacestylerefraction' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneShading: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneShading" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3.ifcsurfacestyleshading' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneTextures: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneTextures" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3.ifcsurfacestylewithtextures' in typeof(style)])) <= 1 + + + + + + + + + + + + + + + + + + + + + + + +class IfcSweptAreaSolid_SweptAreaType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptAreaSolid" + RULE_NAME = "SweptAreaType" + + @staticmethod + def __call__(self): + sweptarea = self.SweptArea + + assert sweptarea.ProfileType == IfcProfileTypeEnum.Area + + + + + +class IfcSweptDiskSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x3.ifcconic','ifc4x3.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + +class IfcSweptDiskSolid_DirectrixDim: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixDim" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSweptDiskSolid_InnerRadiusSize: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "InnerRadiusSize" + + @staticmethod + def __call__(self): + radius = self.Radius + innerradius = self.InnerRadius + + assert (not exists(innerradius)) or (radius > innerradius) + + + + + +class IfcSweptDiskSolidPolygonal_CorrectRadii: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "CorrectRadii" + + @staticmethod + def __call__(self): + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or (filletradius >= self.Radius) + + + + +class IfcSweptDiskSolidPolygonal_DirectrixIsPolyline: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "DirectrixIsPolyline" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3.ifcpolyline' in typeof(self.Directrix)) or (('ifc4x3.ifcindexedpolycurve' in typeof(self.Directrix)) and (not exists(self.Directrix.Segments))) + + + + + +class IfcSweptSurface_SweptCurveType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptSurface" + RULE_NAME = "SweptCurveType" + + @staticmethod + def __call__(self): + sweptcurve = self.SweptCurve + + assert sweptcurve.ProfileType == IfcProfileTypeEnum.Curve + + + + + +class IfcSwitchingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSwitchingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcswitchingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSwitchingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSystemFurnitureElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSystemFurnitureElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcsystemfurnitureelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSystemFurnitureElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < depth + + + + +class IfcTShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcTable_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + rows = self.Rows + + assert (sizeof([temp for temp in rows if hiindex(temp.RowCells) != (hiindex(rows[1 - 1].RowCells))])) == 0 + + + + +class IfcTable_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + numberofheadings = self.NumberOfHeadings + + assert 0 <= numberofheadings <= 1 + + + + +def calc_IfcTable_NumberOfCellsInRow(self): + rows = self.Rows + return \ + hiindex(rows[1 - 1].RowCells) + + + +def calc_IfcTable_NumberOfHeadings(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if temp.IsHeading]) + + + +def calc_IfcTable_NumberOfDataRows(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if not temp.IsHeading]) + + + + + + + + + + +class IfcTank_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTank_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifctanktype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTankType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTankType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTask_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTask_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + + + + + + + +class IfcTaskType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTaskType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + +class IfcTelecomAddress_MinimumDataProvided: + SCOPE = "entity" + TYPE_NAME = "IfcTelecomAddress" + RULE_NAME = "MinimumDataProvided" + + @staticmethod + def __call__(self): + telephonenumbers = self.TelephoneNumbers + facsimilenumbers = self.FacsimileNumbers + pagernumber = self.PagerNumber + electronicmailaddresses = self.ElectronicMailAddresses + wwwhomepageurl = self.WWWHomePageURL + messagingids = self.MessagingIDs + + assert exists(telephonenumbers) or exists(facsimilenumbers) or exists(pagernumber) or exists(electronicmailaddresses) or exists(wwwhomepageurl) or exists(messagingids) + + + + + +class IfcTendon_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendon_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifctendontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonAnchor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifctendonanchortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonConduit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonConduit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifctendonconduittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonConduitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcTessellatedFaceSet_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcTextLiteralWithExtent_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcTextLiteralWithExtent" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + extent = self.Extent + + assert not 'ifc4x3.ifcplanarbox' in typeof(extent) + + + + + + + + +class IfcTextStyleFontModel_MeasureOfFontSize: + SCOPE = "entity" + TYPE_NAME = "IfcTextStyleFontModel" + RULE_NAME = "MeasureOfFontSize" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3.ifclengthmeasure' in typeof(self.FontSize)) and (self.FontSize > 0.) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTopologyRepresentation_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x3.ifctopologicalrepresentationitem' in typeof(temp)])) == 0 + + + + +class IfcTopologyRepresentation_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcTopologyRepresentation_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + + + assert IfcTopologyRepresentationTypes(self.RepresentationType,self.Items) + + + + + +class IfcToroidalSurface_MajorLargerMinor: + SCOPE = "entity" + TYPE_NAME = "IfcToroidalSurface" + RULE_NAME = "MajorLargerMinor" + + @staticmethod + def __call__(self): + majorradius = self.MajorRadius + minorradius = self.MinorRadius + + assert minorradius < majorradius + + + + + +class IfcTrackElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTrackElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTrackElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTrackElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifctrackelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTrackElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTrackElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTrackElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTransformer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransformer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifctransformertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransformerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTransportElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransportElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransportElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransportElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifctransportelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransportElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransportElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransportElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +def calc_IfcTriangulatedFaceSet_NumberOfTriangles(self): + coordindex = self.CoordIndex + return \ + sizeof(coordindex) + + + + +class IfcTriangulatedIrregularNetwork_NotClosed: + SCOPE = "entity" + TYPE_NAME = "IfcTriangulatedIrregularNetwork" + RULE_NAME = "NotClosed" + + @staticmethod + def __call__(self): + + + assert self.Closed == False + + + + + +class IfcTrimmedCurve_NoTrimOfBoundedCurves: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "NoTrimOfBoundedCurves" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert not 'ifc4x3.ifcboundedcurve' in typeof(basiscurve) + + + + +class IfcTrimmedCurve_Trim1ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim1ValuesConsistent" + + @staticmethod + def __call__(self): + trim1 = self.Trim1 + + assert (hiindex(trim1) == 1) or ((typeof(trim1[1 - 1])) != (typeof(trim1[2 - 1]))) + + + + +class IfcTrimmedCurve_Trim2ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim2ValuesConsistent" + + @staticmethod + def __call__(self): + trim2 = self.Trim2 + + assert (hiindex(trim2) == 1) or ((typeof(trim2[1 - 1])) != (typeof(trim2[2 - 1]))) + + + + + +class IfcTubeBundle_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTubeBundle_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifctubebundletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTubeBundleType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundleType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTypeObject_NameRequired: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "NameRequired" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTypeObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + haspropertysets = self.HasPropertySets + + assert (not exists(haspropertysets)) or IfcUniquePropertySetNames(haspropertysets) + + + + + + + + +class IfcTypeProduct_ApplicableOccurrence: + SCOPE = "entity" + TYPE_NAME = "IfcTypeProduct" + RULE_NAME = "ApplicableOccurrence" + + @staticmethod + def __call__(self): + + + assert (not exists(lambda: self.Types[1 - 1])) or ((sizeof([temp for temp in self.Types[1 - 1].RelatedObjects if not 'ifc4x3.ifcproduct' in typeof(temp)])) == 0) + + + + + + + + +class IfcUShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + +class IfcUShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcUnitAssignment_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcUnitAssignment" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + units = self.Units + + assert IfcCorrectUnitAssignment(units) + + + + + +class IfcUnitaryControlElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryControlElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcunitarycontrolelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryControlElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcUnitaryEquipment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryEquipment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcunitaryequipmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryEquipmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcValve_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcValve_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcvalvetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcValveType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValveType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVector_MagGreaterOrEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcVector" + RULE_NAME = "MagGreaterOrEqualZero" + + @staticmethod + def __call__(self): + magnitude = self.Magnitude + + assert magnitude >= 0.0 + + + + +def calc_IfcVector_Dim(self): + orientation = self.Orientation + return \ + orientation.Dim + + + + +class IfcVehicle_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVehicle" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVehicleTypeEnum.USERDEFINED) or ((predefinedtype == IfcVehicleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVehicle_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVehicle" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcvehicletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVehicleType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVehicleType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVehicleTypeEnum.USERDEFINED) or ((predefinedtype == IfcVehicleTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcVibrationDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcvibrationdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVibrationIsolator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationIsolator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcvibrationisolatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationIsolatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVirtualElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVirtualElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVirtualElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcVirtualElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcVoidingFeature_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVoidingFeature" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVoidingFeatureTypeEnum.USERDEFINED) or ((predefinedtype == IfcVoidingFeatureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVoidingFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcVoidingFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVoidingFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWallStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcWallStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3.ifcrelassociates.relatedobjects') if ('ifc4x3.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWasteTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWasteTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcwasteterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWasteTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWindow_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWindowTypeEnum.USERDEFINED) or ((predefinedtype == IfcWindowTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWindow_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3.ifcwindowtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWindowLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcWindowLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + firsttransomoffset = self.FirstTransomOffset + secondtransomoffset = self.SecondTransomOffset + + assert not (not exists(firsttransomoffset)) and exists(secondtransomoffset) + + + + +class IfcWindowLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + firstmullionoffset = self.FirstMullionOffset + secondmullionoffset = self.SecondMullionOffset + + assert not (not exists(firstmullionoffset)) and exists(secondmullionoffset) + + + + +class IfcWindowLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcWindowPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcWindowType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWindowTypeEnum.USERDEFINED) or ((predefinedtype == IfcWindowTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWorkCalendar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkCalendar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkCalendarTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkCalendarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcWorkPlan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkPlan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkPlanTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkPlanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcWorkSchedule_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkSchedule" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkScheduleTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkScheduleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcZShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcZShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + + +class IfcZone_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcZone" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof(self.IsGroupedBy) == 0) or ((sizeof([temp for temp in self.IsGroupedBy[1 - 1].RelatedObjects if not ('ifc4x3.ifczone' in typeof(temp)) or ('ifc4x3.ifcspace' in typeof(temp)) or ('ifc4x3.ifcspatialzone' in typeof(temp))])) == 0) + + + + + +class IfcRepresentationContextSameWCS: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcGeometricRepresentationContext = file.by_type("IfcGeometricRepresentationContext") + isdifferent = False + if sizeof(IfcGeometricRepresentationContext) > 1: + for i in range(2, hiindex(IfcGeometricRepresentationContext) + 1): + if (IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem) != (IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem): + isdifferent = (not IfcSameValidPrecision(IfcGeometricRepresentationContext[1 - 1].Precision,IfcGeometricRepresentationContext[i - 1].Precision)) or (not IfcSameAxis2Placement(IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[1 - 1].Precision)) + if isdifferent == True: + break + + assert isdifferent == False + + + + + +class IfcSingleProjectInstance: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcProject = file.by_type("IfcProject") + + + + assert sizeof(IfcProject) <= 1 + + + + +def IfcAssociatedSurface(arg): + + surf = arg.BasisSurface + return surf + + +def IfcBaseAxis(dim, axis1, axis2, axis3): + + + + if dim == 3: + d1 = nvl(IfcNormalise(axis3),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,axis1) + u = [d2,IfcSecondProjAxis(d1,d2,axis2),d1] + else: + if exists(axis1): + d1 = IfcNormalise(axis1) + u = [d1,IfcOrthogonalComplement(d1)] + if exists(axis2): + factor = IfcDotProduct(axis2,u[2 - 1]) + if factor < 0.0: + u[2 - 1].DirectionRatios[1 - 1] = -u[2 - 1].DirectionRatios[1 - 1] + u[2 - 1].DirectionRatios[2 - 1] = -u[2 - 1].DirectionRatios[2 - 1] + else: + if exists(axis2): + d1 = IfcNormalise(axis2) + u = [IfcOrthogonalComplement(d1),d1] + u[1 - 1].DirectionRatios[1 - 1] = -u[1 - 1].DirectionRatios[1 - 1] + u[1 - 1].DirectionRatios[2 - 1] = -u[1 - 1].DirectionRatios[2 - 1] + else: + u = [IfcDirection(DirectionRatios=[1.0,0.0]),IfcDirection(DirectionRatios=[0.0,1.0])] + return u + + +def IfcBooleanChoose(b, choice1, choice2): + + if b: + return choice1 + else: + return choice2 + + +def IfcBuild2Axes(refdirection): + d = nvl(IfcNormalise(refdirection),IfcDirection(DirectionRatios=[1.0,0.0])) + return [d,IfcOrthogonalComplement(d)] + + +def IfcBuildAxes(axis, refdirection): + + d1 = nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,refdirection) + return [d2,IfcNormalise(IfcCrossProduct(d1,d2)).Orientation,d1] + + +def IfcConsecutiveSegments(segments): + result = True + for i in range(1, hiindex(segments) - 1 + 1): + if (segments[i - 1][hiindex(segments[i - 1]) - 1]) != (segments[i - 1][1 - 1]): + result = False + break + return result + + +def IfcConstraintsParamBSpline(degree, upknots, upcp, knotmult, knots): + result = True + + sum = knotmult[1 - 1] + for i in range(2, upknots + 1): + sum = sum + (knotmult[i - 1]) + if (degree < 1) or (upknots < 2) or (upcp < degree) or (sum != (degree + upcp + 2)): + result = False + return result + k = knotmult[1 - 1] + if (k < 1) or (k > (degree + 1)): + result = False + return result + for i in range(2, upknots + 1): + if ((knotmult[i - 1]) < 1) or ((knots[i - 1]) <= (knots[i - 1])): + result = False + return result + k = knotmult[i - 1] + if (i < upknots) and (k > degree): + result = False + return result + if (i == upknots) and (k > (degree + 1)): + result = False + return result + return result + + +def IfcConvertDirectionInto2D(direction): + direction2d = IfcDirection(DirectionRatios=[0.,1.]) + temp = list(direction2d.DirectionRatios) + temp[1 - 1] = direction.DirectionRatios[1 - 1] + direction2d.DirectionRatios = temp + temp = list(direction2d.DirectionRatios) + temp[2 - 1] = direction.DirectionRatios[2 - 1] + direction2d.DirectionRatios = temp + return direction2d + + +def IfcCorrectDimensions(m, dim): + + if m == lengthunit: + if dim == IfcDimensionalExponents(1,0,0,0,0,0,0): + return True + else: + return False + elif m == massunit: + if dim == IfcDimensionalExponents(0,1,0,0,0,0,0): + return True + else: + return False + elif m == timeunit: + if dim == IfcDimensionalExponents(0,0,1,0,0,0,0): + return True + else: + return False + elif m == electriccurrentunit: + if dim == IfcDimensionalExponents(0,0,0,1,0,0,0): + return True + else: + return False + elif m == thermodynamictemperatureunit: + if dim == IfcDimensionalExponents(0,0,0,0,1,0,0): + return True + else: + return False + elif m == amountofsubstanceunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,1,0): + return True + else: + return False + elif m == luminousintensityunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == planeangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == solidangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == areaunit: + if dim == IfcDimensionalExponents(2,0,0,0,0,0,0): + return True + else: + return False + elif m == volumeunit: + if dim == IfcDimensionalExponents(3,0,0,0,0,0,0): + return True + else: + return False + elif m == absorbeddoseunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == radioactivityunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == electriccapacitanceunit: + if dim == IfcDimensionalExponents(-2,-1,4,2,0,0,0): + return True + else: + return False + elif m == doseequivalentunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == electricchargeunit: + if dim == IfcDimensionalExponents(0,0,1,1,0,0,0): + return True + else: + return False + elif m == electricconductanceunit: + if dim == IfcDimensionalExponents(-2,-1,3,2,0,0,0): + return True + else: + return False + elif m == electricvoltageunit: + if dim == IfcDimensionalExponents(2,1,-3,-1,0,0,0): + return True + else: + return False + elif m == electricresistanceunit: + if dim == IfcDimensionalExponents(2,1,-3,-2,0,0,0): + return True + else: + return False + elif m == energyunit: + if dim == IfcDimensionalExponents(2,1,-2,0,0,0,0): + return True + else: + return False + elif m == forceunit: + if dim == IfcDimensionalExponents(1,1,-2,0,0,0,0): + return True + else: + return False + elif m == frequencyunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == inductanceunit: + if dim == IfcDimensionalExponents(2,1,-2,-2,0,0,0): + return True + else: + return False + elif m == illuminanceunit: + if dim == IfcDimensionalExponents(-2,0,0,0,0,0,1): + return True + else: + return False + elif m == luminousfluxunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == magneticfluxunit: + if dim == IfcDimensionalExponents(2,1,-2,-1,0,0,0): + return True + else: + return False + elif m == magneticfluxdensityunit: + if dim == IfcDimensionalExponents(0,1,-2,-1,0,0,0): + return True + else: + return False + elif m == powerunit: + if dim == IfcDimensionalExponents(2,1,-3,0,0,0,0): + return True + else: + return False + elif m == pressureunit: + if dim == IfcDimensionalExponents(-1,1,-2,0,0,0,0): + return True + else: + return False + else: + return unknown + + +def IfcCorrectFillAreaStyle(styles): + hatching = 0 + tiles = 0 + colour = 0 + external = 0 + external = sizeof([style for style in styles if 'ifc4x3.ifcexternallydefinedhatchstyle' in typeof(style)]) + hatching = sizeof([style for style in styles if 'ifc4x3.ifcfillareastylehatching' in typeof(style)]) + tiles = sizeof([style for style in styles if 'ifc4x3.ifcfillareastyletiles' in typeof(style)]) + colour = sizeof([style for style in styles if 'ifc4x3.ifccolour' in typeof(style)]) + if external > 1: + return False + if (external == 1) and ((hatching > 0) or (tiles > 0) or (colour > 0)): + return False + if colour > 1: + return False + if (hatching > 0) and (tiles > 0): + return False + return True + + +def IfcCorrectLocalPlacement(axisplacement, relplacement): + + if exists(relplacement): + if 'ifc4x3.ifcgridplacement' in typeof(relplacement): + return None + if 'ifc4x3.ifclocalplacement' in typeof(relplacement): + if 'ifc4x3.ifcaxis2placement2d' in typeof(axisplacement): + return True + if 'ifc4x3.ifcaxis2placement3d' in typeof(axisplacement): + if relplacement.RelativePlacement.Dim == 3: + return True + else: + return False + return True + return None + + +def IfcCorrectObjectAssignment(constraint, objects): + count = 0 + if not exists(constraint): + return True + if constraint == IfcObjectTypeEnum.NOTDEFINED: + return True + elif constraint == IfcObjectTypeEnum.PRODUCT: + count = sizeof([temp for temp in objects if not 'ifc4x3.ifcproduct' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROCESS: + count = sizeof([temp for temp in objects if not 'ifc4x3.ifcprocess' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.CONTROL: + count = sizeof([temp for temp in objects if not 'ifc4x3.ifccontrol' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.RESOURCE: + count = sizeof([temp for temp in objects if not 'ifc4x3.ifcresource' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.ACTOR: + count = sizeof([temp for temp in objects if not 'ifc4x3.ifcactor' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.GROUP: + count = sizeof([temp for temp in objects if not 'ifc4x3.ifcgroup' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROJECT: + count = sizeof([temp for temp in objects if not 'ifc4x3.ifcproject' in typeof(temp)]) + return count == 0 + else: + return None + + +def IfcCorrectUnitAssignment(units): + namedunitnumber = 0 + derivedunitnumber = 0 + monetaryunitnumber = 0 + namedunitnames = express_set([]) + derivedunitnames = express_set([]) + namedunitnumber = sizeof([temp for temp in units if ('ifc4x3.ifcnamedunit' in typeof(temp)) and (not temp.UnitType == IfcUnitEnum.USERDEFINED)]) + derivedunitnumber = sizeof([temp for temp in units if ('ifc4x3.ifcderivedunit' in typeof(temp)) and (not temp.UnitType == IfcDerivedUnitEnum.USERDEFINED)]) + monetaryunitnumber = sizeof([temp for temp in units if 'ifc4x3.ifcmonetaryunit' in typeof(temp)]) + for i in range(1, sizeof(units) + 1): + if ('ifc4x3.ifcnamedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcUnitEnum.USERDEFINED): + namedunitnames = namedunitnames + (units[i - 1].UnitType) + if ('ifc4x3.ifcderivedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcDerivedUnitEnum.USERDEFINED): + derivedunitnames = derivedunitnames + (units[i - 1].UnitType) + return (sizeof(namedunitnames) == namedunitnumber) and (sizeof(derivedunitnames) == derivedunitnumber) and (monetaryunitnumber <= 1) + + +def IfcCrossProduct(arg1, arg2): + + + + + if ((not exists(arg1)) or (arg1.Dim == 2)) or ((not exists(arg2)) or (arg2.Dim == 2)): + return None + else: + v1 = IfcNormalise(arg1).DirectionRatios + v2 = IfcNormalise(arg2).DirectionRatios + res = IfcDirection(DirectionRatios=[((v1[2 - 1]) * (v2[3 - 1])) - ((v1[3 - 1]) * (v2[2 - 1])),((v1[3 - 1]) * (v2[1 - 1])) - ((v1[1 - 1]) * (v2[3 - 1])),((v1[1 - 1]) * (v2[2 - 1])) - ((v1[2 - 1]) * (v2[1 - 1]))]) + mag = 0.0 + for i in range(1, 3 + 1): + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=arg1, Magnitude=0.0) + return result + + +def IfcCurveDim(curve): + + if 'ifc4x3.ifcline' in typeof(curve): + return curve.Pnt.Dim + if 'ifc4x3.ifcconic' in typeof(curve): + return curve.Position.Dim + if 'ifc4x3.ifcpolyline' in typeof(curve): + return curve.Points[1 - 1].Dim + if 'ifc4x3.ifctrimmedcurve' in typeof(curve): + return IfcCurveDim(curve.BasisCurve) + if 'ifc4x3.ifcgradientcurve' in typeof(curve): + return 3 + if 'ifc4x3.ifcsegmentedreferencecurve' in typeof(curve): + return 3 + if 'ifc4x3.ifccompositecurve' in typeof(curve): + return curve.Segments[1 - 1].Dim + if 'ifc4x3.ifcbsplinecurve' in typeof(curve): + return curve.ControlPointsList[1 - 1].Dim + if 'ifc4x3.ifcoffsetcurve2d' in typeof(curve): + return 2 + if 'ifc4x3.ifcoffsetcurve3d' in typeof(curve): + return 3 + if 'ifc4x3.ifcoffsetcurvebydistances' in typeof(curve): + return 3 + if 'ifc4x3.ifccurvesegment2d' in typeof(curve): + return 2 + if 'ifc4x3.ifcpolynomialcurve' in typeof(curve): + if (not exists(curve.CoefficientsZ)) and (curve.Position.Dim == 2): + return 2 + return 3 + if 'ifc4x3.ifcpcurve' in typeof(curve): + return 3 + if 'ifc4x3.ifcindexedpolycurve' in typeof(curve): + return curve.Points.Dim + return None + + +def IfcCurveWeightsPositive(b): + result = True + for i in range(0, b.UpperIndexOnControlPoints + 1): + if (b.Weights[i - 1]) <= 0.0: + result = False + return result + return result + + +def IfcDeriveDimensionalExponents(unitelements): + result = IfcDimensionalExponents(0,0,0,0,0,0,0) + for i in range(loindex(unitelements), hiindex(unitelements) + 1): + result.LengthExponent = result.LengthExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LengthExponent)) + result.MassExponent = result.MassExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.MassExponent)) + result.TimeExponent = result.TimeExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.TimeExponent)) + result.ElectricCurrentExponent = result.ElectricCurrentExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ElectricCurrentExponent)) + result.ThermodynamicTemperatureExponent = result.ThermodynamicTemperatureExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ThermodynamicTemperatureExponent)) + result.AmountOfSubstanceExponent = result.AmountOfSubstanceExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.AmountOfSubstanceExponent)) + result.LuminousIntensityExponent = result.LuminousIntensityExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LuminousIntensityExponent)) + return result + + +def IfcDimensionsForSIUnit(n): + + if n == metre: + return IfcDimensionalExponents(1,0,0,0,0,0,0) + elif n == square_metre: + return IfcDimensionalExponents(2,0,0,0,0,0,0) + elif n == cubic_metre: + return IfcDimensionalExponents(3,0,0,0,0,0,0) + elif n == gram: + return IfcDimensionalExponents(0,1,0,0,0,0,0) + elif n == second: + return IfcDimensionalExponents(0,0,1,0,0,0,0) + elif n == ampere: + return IfcDimensionalExponents(0,0,0,1,0,0,0) + elif n == kelvin: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == mole: + return IfcDimensionalExponents(0,0,0,0,0,1,0) + elif n == candela: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == radian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == steradian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == hertz: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == newton: + return IfcDimensionalExponents(1,1,-2,0,0,0,0) + elif n == pascal: + return IfcDimensionalExponents(-1,1,-2,0,0,0,0) + elif n == joule: + return IfcDimensionalExponents(2,1,-2,0,0,0,0) + elif n == watt: + return IfcDimensionalExponents(2,1,-3,0,0,0,0) + elif n == coulomb: + return IfcDimensionalExponents(0,0,1,1,0,0,0) + elif n == volt: + return IfcDimensionalExponents(2,1,-3,-1,0,0,0) + elif n == farad: + return IfcDimensionalExponents(-2,-1,4,2,0,0,0) + elif n == ohm: + return IfcDimensionalExponents(2,1,-3,-2,0,0,0) + elif n == siemens: + return IfcDimensionalExponents(-2,-1,3,2,0,0,0) + elif n == weber: + return IfcDimensionalExponents(2,1,-2,-1,0,0,0) + elif n == tesla: + return IfcDimensionalExponents(0,1,-2,-1,0,0,0) + elif n == henry: + return IfcDimensionalExponents(2,1,-2,-2,0,0,0) + elif n == degree_celsius: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == lumen: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == lux: + return IfcDimensionalExponents(-2,0,0,0,0,0,1) + elif n == becquerel: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == gray: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + elif n == sievert: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + else: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + + +def IfcDotProduct(arg1, arg2): + + + + if (not exists(arg1)) or (not exists(arg2)): + scalar = None + else: + if arg1.Dim != arg2.Dim: + scalar = None + else: + vec1 = IfcNormalise(arg1) + vec2 = IfcNormalise(arg2) + ndim = arg1.Dim + scalar = 0.0 + for i in range(1, ndim + 1): + scalar = scalar + ((vec1.DirectionRatios[i - 1]) * (vec2.DirectionRatios[i - 1])) + return scalar + + +def IfcFirstProjAxis(zaxis, arg): + + + + + if not exists(zaxis): + return None + else: + z = IfcNormalise(zaxis) + if not exists(arg): + if z.DirectionRatios != [1.0,0.0,0.0]: + v = IfcDirection(DirectionRatios=[1.0,0.0,0.0]) + else: + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + if arg.Dim != 3: + return None + if IfcCrossProduct(arg,z).Magnitude == 0.0: + return None + else: + v = IfcNormalise(arg) + xvec = IfcScalarTimesVector(IfcDotProduct(v,z),z) + xaxis = IfcVectorDifference(v,xvec).Orientation + xaxis = IfcNormalise(xaxis) + return xaxis + + +def IfcGetBasisSurface(c): + + + surfs = [] + if 'ifc4x3.ifcpcurve' in typeof(c): + surfs = [c.BasisSurface] + else: + if 'ifc4x3.ifcsurfacecurve' in typeof(c): + n = sizeof(c.AssociatedGeometry) + for i in range(1, n + 1): + surfs = surfs + (IfcAssociatedSurface(c.AssociatedGeometry[i - 1])) + if 'ifc4x3.ifccompositecurveonsurface' in typeof(c): + n = sizeof(c.Segments) + surfs = IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve) + if n > 1: + for i in range(2, n + 1): + surfs = surfs * (IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve)) + return surfs + + +def IfcGradient(gradientcurve): + + return 1 + + +def IfcListToArray(lis, low, u): + + + n = sizeof(lis) + if n != (u - low + 1): + return None + else: + res = ([lis[1 - 1]] * n) + for i in range(2, n + 1): + temp = list(res) + temp[low - 1] = lis[i - 1] + res = temp + return res + + +def IfcLoopHeadToTail(aloop): + + p = True + n = sizeof(aloop.EdgeList) + for i in range(2, n + 1): + p = p and ((aloop.EdgeList[i - 1].EdgeEnd) == (aloop.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcMakeArrayOfArray(lis, low1, u1, low2, u2): + + if (u1 - low1 + 1) != sizeof(lis): + return None + if (u2 - low2 + 1) != (sizeof(lis[1 - 1])): + return None + res = ([IfcListToArray(lis[1 - 1],low2,u2)] * u1 - low1 + 1) + for i in range(2, hiindex(lis) + 1): + if (u2 - low2 + 1) != (sizeof(lis[i - 1])): + return None + temp = list(res) + temp[low1 - 1] = IfcListToArray(lis[i - 1],low2,u2) + res = temp + return res + + +def IfcMlsTotalThickness(layerset): + max = layerset.MaterialLayers[1 - 1].LayerThickness + if sizeof(layerset.MaterialLayers) > 1: + for i in range(2, hiindex(layerset.MaterialLayers) + 1): + max = max + (layerset.MaterialLayers[i - 1].LayerThickness) + return max + + +def IfcNormalise(arg): + + v = IfcDirection(DirectionRatios=[1.,0.]) + vec = IfcVector(Orientation=IfcDirection(DirectionRatios=[1.,0.]), Magnitude=1.) + + result = v + if not exists(arg): + return None + else: + if 'ifc4x3.ifcvector' in typeof(arg): + ndim = arg.Dim + v.DirectionRatios = arg.Orientation.DirectionRatios + vec.Magnitude = arg.Magnitude + vec.Orientation = v + if arg.Magnitude == 0.0: + return None + else: + vec.Magnitude = 1.0 + else: + ndim = arg.Dim + v.DirectionRatios = arg.DirectionRatios + mag = 0.0 + for i in range(1, ndim + 1): + mag = mag + ((v.DirectionRatios[i - 1]) * (v.DirectionRatios[i - 1])) + if mag > 0.0: + mag = sqrt(mag) + for i in range(1, ndim + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = (v.DirectionRatios[i - 1]) / mag + v.DirectionRatios = temp + if 'ifc4x3.ifcvector' in typeof(arg): + vec.Orientation = v + result = vec + else: + result = v + else: + return None + return result + + +def IfcOrthogonalComplement(vec): + + if (not exists(vec)) or (vec.Dim != 2): + return None + else: + result = IfcDirection(DirectionRatios=[-vec.DirectionRatios[2 - 1],vec.DirectionRatios[1 - 1]]) + return result + + +def IfcPathHeadToTail(apath): + n = 0 + p = unknown + n = sizeof(apath.EdgeList) + for i in range(2, n + 1): + p = p and ((apath.EdgeList[i - 1].EdgeEnd) == (apath.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcPointListDim(pointlist): + + if 'ifc4x3.ifccartesianpointlist2d' in typeof(pointlist): + return 2 + if 'ifc4x3.ifccartesianpointlist3d' in typeof(pointlist): + return 3 + return None + + +def IfcSameAxis2Placement(ap1, ap2, epsilon): + + return (IfcSameDirection(ap1.P[1 - 1],ap2.P[1 - 1],epsilon)) and (IfcSameDirection(ap1.P[2 - 1],ap2.P[2 - 1],epsilon)) and IfcSameCartesianPoint(ap1.Location,ap1.Location,epsilon) + + +def IfcSameCartesianPoint(cp1, cp2, epsilon): + cp1x = cp1.Coordinates[1 - 1] + cp1y = cp1.Coordinates[2 - 1] + cp1z = 0 + cp2x = cp2.Coordinates[1 - 1] + cp2y = cp2.Coordinates[2 - 1] + cp2z = 0 + if sizeof(cp1.Coordinates) > 2: + cp1z = cp1.Coordinates[3 - 1] + if sizeof(cp2.Coordinates) > 2: + cp2z = cp2.Coordinates[3 - 1] + return IfcSameValue(cp1x,cp2x,epsilon) and IfcSameValue(cp1y,cp2y,epsilon) and IfcSameValue(cp1z,cp2z,epsilon) + + +def IfcSameDirection(dir1, dir2, epsilon): + dir1x = dir1.DirectionRatios[1 - 1] + dir1y = dir1.DirectionRatios[2 - 1] + dir1z = 0 + dir2x = dir2.DirectionRatios[1 - 1] + dir2y = dir2.DirectionRatios[2 - 1] + dir2z = 0 + if sizeof(dir1.DirectionRatios) > 2: + dir1z = dir1.DirectionRatios[3 - 1] + if sizeof(dir2.DirectionRatios) > 2: + dir2z = dir2.DirectionRatios[3 - 1] + return IfcSameValue(dir1x,dir2x,epsilon) and IfcSameValue(dir1y,dir2y,epsilon) and IfcSameValue(dir1z,dir2z,epsilon) + + +def IfcSameValidPrecision(epsilon1, epsilon2): + + defaulteps = 0.000001 + derivationofeps = 1.001 + uppereps = 1.0 + valideps1 = nvl(epsilon1,defaulteps) + valideps2 = nvl(epsilon2,defaulteps) + return (0.0 < valideps1) and (valideps1 <= (derivationofeps * valideps2)) and (valideps2 <= (derivationofeps * valideps1)) and (valideps2 < uppereps) + + +def IfcSameValue(value1, value2, epsilon): + + defaulteps = 0.000001 + valideps = nvl(epsilon,defaulteps) + return ((value1 + valideps) > value2) and (value1 < (value2 + valideps)) + + +def IfcScalarTimesVector(scalar, vec): + + + + if (not exists(scalar)) or (not exists(vec)): + return None + else: + if 'ifc4x3.ifcvector' in typeof(vec): + v = vec.Orientation + mag = scalar * vec.Magnitude + else: + v = vec + mag = scalar + if mag < 0.0: + for i in range(1, sizeof(v.DirectionRatios) + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = -v.DirectionRatios[i - 1] + v.DirectionRatios = temp + mag = -mag + result = IfcVector(Orientation=IfcNormalise(v), Magnitude=mag) + return result + + +def IfcSecondProjAxis(zaxis, xaxis, arg): + + + + if not exists(arg): + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + v = arg + temp = IfcScalarTimesVector(IfcDotProduct(v,zaxis),zaxis) + yaxis = IfcVectorDifference(v,temp) + temp = IfcScalarTimesVector(IfcDotProduct(v,xaxis),xaxis) + yaxis = IfcVectorDifference(yaxis,temp) + yaxis = IfcNormalise(yaxis) + return yaxis.Orientation + + +def IfcShapeRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'point': + count = sizeof([temp for temp in items if 'ifc4x3.ifcpoint' in typeof(temp)]) + elif reptype.lower() == 'pointcloud': + count = sizeof([temp for temp in items if 'ifc4x3.ifccartesianpointlist3d' in typeof(temp)]) + elif reptype.lower() == 'curve': + count = sizeof([temp for temp in items if 'ifc4x3.ifccurve' in typeof(temp)]) + elif reptype.lower() == 'curve2d': + count = sizeof([temp for temp in items if ('ifc4x3.ifccurve' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'curve3d': + count = sizeof([temp for temp in items if ('ifc4x3.ifccurve' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'segment': + count = sizeof([temp for temp in items if 'ifc4x3.ifcsegment' in typeof(temp)]) + elif reptype.lower() == 'surface': + count = sizeof([temp for temp in items if 'ifc4x3.ifcsurface' in typeof(temp)]) + elif reptype.lower() == 'surface2d': + count = sizeof([temp for temp in items if ('ifc4x3.ifcsurface' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'surface3d': + count = sizeof([temp for temp in items if ('ifc4x3.ifcsurface' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'sectionedsurface': + count = sizeof([temp for temp in items if 'ifc4x3.ifcsectionedsurface' in typeof(temp)]) + elif reptype.lower() == 'fillarea': + count = sizeof([temp for temp in items if 'ifc4x3.ifcannotationfillarea' in typeof(temp)]) + elif reptype.lower() == 'text': + count = sizeof([temp for temp in items if 'ifc4x3.ifctextliteral' in typeof(temp)]) + elif reptype.lower() == 'advancedsurface': + count = sizeof([temp for temp in items if 'ifc4x3.ifcbsplinesurface' in typeof(temp)]) + elif reptype.lower() == 'annotation2d': + count = sizeof([temp for temp in items if (sizeof(typeof(temp) * ['ifc4x3.ifcpoint','ifc4x3.ifccurve','ifc4x3.ifcgeometriccurveset','ifc4x3.ifcannotationfillarea','ifc4x3.ifctextliteral'])) == 1]) + elif reptype.lower() == 'geometricset': + count = sizeof([temp for temp in items if ('ifc4x3.ifcgeometricset' in typeof(temp)) or ('ifc4x3.ifcpoint' in typeof(temp)) or ('ifc4x3.ifccurve' in typeof(temp)) or ('ifc4x3.ifcsurface' in typeof(temp))]) + elif reptype.lower() == 'geometriccurveset': + count = sizeof([temp for temp in items if ('ifc4x3.ifcgeometriccurveset' in typeof(temp)) or ('ifc4x3.ifcgeometricset' in typeof(temp)) or ('ifc4x3.ifcpoint' in typeof(temp)) or ('ifc4x3.ifccurve' in typeof(temp))]) + for i in range(1, hiindex(items) + 1): + if 'ifc4x3.ifcgeometricset' in (typeof(items[i - 1])): + if (sizeof([temp for temp in items[i - 1].Elements if 'ifc4x3.ifcsurface' in typeof(temp)])) > 0: + count = count - 1 + elif reptype.lower() == 'tessellation': + count = sizeof([temp for temp in items if 'ifc4x3.ifctessellateditem' in typeof(temp)]) + elif reptype.lower() == 'surfaceorsolidmodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3.ifctessellateditem','ifc4x3.ifcshellbasedsurfacemodel','ifc4x3.ifcfacebasedsurfacemodel','ifc4x3.ifcsolidmodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'surfacemodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3.ifctessellateditem','ifc4x3.ifcshellbasedsurfacemodel','ifc4x3.ifcfacebasedsurfacemodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'solidmodel': + count = sizeof([temp for temp in items if 'ifc4x3.ifcsolidmodel' in typeof(temp)]) + elif reptype.lower() == 'sweptsolid': + count = sizeof([temp for temp in items if ((sizeof(['ifc4x3.ifcextrudedareasolid','ifc4x3.ifcrevolvedareasolid'] * typeof(temp))) >= 1) and ((sizeof(['ifc4x3.ifcextrudedareasolidtapered','ifc4x3.ifcrevolvedareasolidtapered'] * typeof(temp))) == 0)]) + elif reptype.lower() == 'advancedsweptsolid': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3.ifcsweptareasolid','ifc4x3.ifcsweptdisksolid','ifc4x3.ifcsectionedsolidhorizontal'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'csg': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3.ifcbooleanresult','ifc4x3.ifccsgprimitive3d','ifc4x3.ifccsgsolid'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'clipping': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3.ifccsgsolid','ifc4x3.ifcbooleanclippingresult'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'brep': + count = sizeof([temp for temp in items if 'ifc4x3.ifcfacetedbrep' in typeof(temp)]) + elif reptype.lower() == 'advancedbrep': + count = sizeof([temp for temp in items if 'ifc4x3.ifcmanifoldsolidbrep' in typeof(temp)]) + elif reptype.lower() == 'boundingbox': + count = sizeof([temp for temp in items if 'ifc4x3.ifcboundingbox' in typeof(temp)]) + if sizeof(items) > 1: + count = 0 + elif reptype.lower() == 'sectionedspine': + count = sizeof([temp for temp in items if 'ifc4x3.ifcsectionedspine' in typeof(temp)]) + elif reptype.lower() == 'lightsource': + count = sizeof([temp for temp in items if 'ifc4x3.ifclightsource' in typeof(temp)]) + elif reptype.lower() == 'mappedrepresentation': + count = sizeof([temp for temp in items if 'ifc4x3.ifcmappeditem' in typeof(temp)]) + else: + return None + return count == sizeof(items) + + +def IfcSurfaceWeightsPositive(b): + result = True + weights = b.Weights + for i in range(0, b.UUpper + 1): + for j in range(0, b.VUpper + 1): + if (weights[i - 1][j - 1]) <= 0.0: + result = False + return result + return result + + +def IfcTaperedSweptAreaProfiles(startarea, endarea): + result = False + if 'ifc4x3.ifcparameterizedprofiledef' in typeof(startarea): + if 'ifc4x3.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = typeof(startarea) == typeof(endarea) + else: + if 'ifc4x3.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = False + return result + + +def IfcTopologyRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'vertex': + count = sizeof([temp for temp in items if 'ifc4x3.ifcvertex' in typeof(temp)]) + elif reptype.lower() == 'edge': + count = sizeof([temp for temp in items if 'ifc4x3.ifcedge' in typeof(temp)]) + elif reptype.lower() == 'path': + count = sizeof([temp for temp in items if 'ifc4x3.ifcpath' in typeof(temp)]) + elif reptype.lower() == 'face': + count = sizeof([temp for temp in items if 'ifc4x3.ifcface' in typeof(temp)]) + elif reptype.lower() == 'shell': + count = sizeof([temp for temp in items if ('ifc4x3.ifcopenshell' in typeof(temp)) or ('ifc4x3.ifcclosedshell' in typeof(temp))]) + elif reptype.lower() == 'undefined': + return True + else: + return None + return count == sizeof(items) + + +def IfcUniqueDefinitionNames(relations): + + + properties = express_set([]) + + if sizeof(relations) == 0: + return True + for i in range(1, hiindex(relations) + 1): + definition = relations[i - 1].RelatingPropertyDefinition + if 'ifc4x3.ifcpropertysetdefinition' in typeof(definition): + properties = properties + definition + else: + if 'ifc4x3.ifcpropertysetdefinitionset' in typeof(definition): + definitionset = definition + for j in range(1, hiindex(definitionset) + 1): + properties = properties + (definitionset[j - 1]) + result = IfcUniquePropertySetNames(properties) + return result + + +def IfcUniquePropertyName(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniquePropertySetNames(properties): + names = express_set([]) + unnamed = 0 + for i in range(1, hiindex(properties) + 1): + if 'ifc4x3.ifcpropertyset' in (typeof(properties[i - 1])): + names = names + (properties[i - 1].Name) + else: + unnamed = unnamed + 1 + return (sizeof(names) + unnamed) == sizeof(properties) + + +def IfcUniquePropertyTemplateNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniqueQuantityNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcVectorDifference(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x3.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x3.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) - (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + +def IfcVectorSum(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x3.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x3.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) + (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + diff --git a/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_ADD1.py b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_ADD1.py new file mode 100644 index 0000000000..415781d894 --- /dev/null +++ b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_ADD1.py @@ -0,0 +1,25081 @@ +import ifcopenshell + +def exists(v): + if callable(v): + try: return v() is not None + except IndexError as e: return False + else: return v is not None + + + +def nvl(v, default): return v if v is not None else default + + +sizeof = len +hiindex = len +blength = len +loindex = lambda x: 1 +from math import * +unknown = 'UNKNOWN' + +def usedin(inst, ref_name): + if inst is None: + return [] + _, __, attr = ref_name.split('.') + def filter(): + for ref, attr_idx in inst.wrapped_data.file.get_inverse(inst, allow_duplicate=True, with_attribute_indices=True): + if ref.wrapped_data.get_attribute_names()[attr_idx].lower() == attr: + yield ref + return list(filter()) + + +class express_set(set): + def __rmul__(self, other): + return express_set(set(other) & self) + def __add__(self, other): + def make_list(v): + # Comply with 12.6.3 Union operator + if isinstance(v, (list, tuple, set, express_set)): + return list(v) + else: + return [v] + return express_set(list(self) + make_list(other)) + __radd__ = __add__ + def __repr__(self): + return repr(set(self)) + + +def typeof(inst): + if not inst: + # If V evaluates to indeterminate (?), an empty set is returned. + return express_set([]) + schema_name = inst.is_a(True).split('.')[0].lower() + def inner(): + decl = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(inst.is_a()) + while decl: + yield '.'.join((schema_name, decl.name().lower())) + decl = decl.supertype() + return express_set(inner()) + +class enum_namespace: + def __getattr__(self, k): + return k.upper() + + +IfcActionRequestTypeEnum = enum_namespace() + + +email = IfcActionRequestTypeEnum.EMAIL + + +fax = IfcActionRequestTypeEnum.FAX + + +phone = IfcActionRequestTypeEnum.PHONE + + +post = IfcActionRequestTypeEnum.POST + + +verbal = IfcActionRequestTypeEnum.VERBAL + + +userdefined = IfcActionRequestTypeEnum.USERDEFINED + + +notdefined = IfcActionRequestTypeEnum.NOTDEFINED + + +IfcActionSourceTypeEnum = enum_namespace() + + +brakes = IfcActionSourceTypeEnum.BRAKES + + +buoyancy = IfcActionSourceTypeEnum.BUOYANCY + + +completion_g1 = IfcActionSourceTypeEnum.COMPLETION_G1 + + +creep = IfcActionSourceTypeEnum.CREEP + + +current = IfcActionSourceTypeEnum.CURRENT + + +dead_load_g = IfcActionSourceTypeEnum.DEAD_LOAD_G + + +earthquake_e = IfcActionSourceTypeEnum.EARTHQUAKE_E + + +erection = IfcActionSourceTypeEnum.ERECTION + + +fire = IfcActionSourceTypeEnum.FIRE + + +ice = IfcActionSourceTypeEnum.ICE + + +impact = IfcActionSourceTypeEnum.IMPACT + + +impulse = IfcActionSourceTypeEnum.IMPULSE + + +lack_of_fit = IfcActionSourceTypeEnum.LACK_OF_FIT + + +live_load_q = IfcActionSourceTypeEnum.LIVE_LOAD_Q + + +prestressing_p = IfcActionSourceTypeEnum.PRESTRESSING_P + + +propping = IfcActionSourceTypeEnum.PROPPING + + +rain = IfcActionSourceTypeEnum.RAIN + + +settlement_u = IfcActionSourceTypeEnum.SETTLEMENT_U + + +shrinkage = IfcActionSourceTypeEnum.SHRINKAGE + + +snow_s = IfcActionSourceTypeEnum.SNOW_S + + +system_imperfection = IfcActionSourceTypeEnum.SYSTEM_IMPERFECTION + + +temperature_t = IfcActionSourceTypeEnum.TEMPERATURE_T + + +transport = IfcActionSourceTypeEnum.TRANSPORT + + +wave = IfcActionSourceTypeEnum.WAVE + + +wind_w = IfcActionSourceTypeEnum.WIND_W + + +userdefined = IfcActionSourceTypeEnum.USERDEFINED + + +notdefined = IfcActionSourceTypeEnum.NOTDEFINED + + +IfcActionTypeEnum = enum_namespace() + + +extraordinary_a = IfcActionTypeEnum.EXTRAORDINARY_A + + +permanent_g = IfcActionTypeEnum.PERMANENT_G + + +variable_q = IfcActionTypeEnum.VARIABLE_Q + + +userdefined = IfcActionTypeEnum.USERDEFINED + + +notdefined = IfcActionTypeEnum.NOTDEFINED + + +IfcActuatorTypeEnum = enum_namespace() + + +electricactuator = IfcActuatorTypeEnum.ELECTRICACTUATOR + + +handoperatedactuator = IfcActuatorTypeEnum.HANDOPERATEDACTUATOR + + +hydraulicactuator = IfcActuatorTypeEnum.HYDRAULICACTUATOR + + +pneumaticactuator = IfcActuatorTypeEnum.PNEUMATICACTUATOR + + +thermostaticactuator = IfcActuatorTypeEnum.THERMOSTATICACTUATOR + + +userdefined = IfcActuatorTypeEnum.USERDEFINED + + +notdefined = IfcActuatorTypeEnum.NOTDEFINED + + +IfcAddressTypeEnum = enum_namespace() + + +distributionpoint = IfcAddressTypeEnum.DISTRIBUTIONPOINT + + +home = IfcAddressTypeEnum.HOME + + +office = IfcAddressTypeEnum.OFFICE + + +site = IfcAddressTypeEnum.SITE + + +userdefined = IfcAddressTypeEnum.USERDEFINED + + +IfcAirTerminalBoxTypeEnum = enum_namespace() + + +constantflow = IfcAirTerminalBoxTypeEnum.CONSTANTFLOW + + +variableflowpressuredependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREDEPENDANT + + +variableflowpressureindependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREINDEPENDANT + + +userdefined = IfcAirTerminalBoxTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalBoxTypeEnum.NOTDEFINED + + +IfcAirTerminalTypeEnum = enum_namespace() + + +diffuser = IfcAirTerminalTypeEnum.DIFFUSER + + +grille = IfcAirTerminalTypeEnum.GRILLE + + +louvre = IfcAirTerminalTypeEnum.LOUVRE + + +register = IfcAirTerminalTypeEnum.REGISTER + + +userdefined = IfcAirTerminalTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalTypeEnum.NOTDEFINED + + +IfcAirToAirHeatRecoveryTypeEnum = enum_namespace() + + +fixedplatecounterflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECOUNTERFLOWEXCHANGER + + +fixedplatecrossflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECROSSFLOWEXCHANGER + + +fixedplateparallelflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATEPARALLELFLOWEXCHANGER + + +heatpipe = IfcAirToAirHeatRecoveryTypeEnum.HEATPIPE + + +rotarywheel = IfcAirToAirHeatRecoveryTypeEnum.ROTARYWHEEL + + +runaroundcoilloop = IfcAirToAirHeatRecoveryTypeEnum.RUNAROUNDCOILLOOP + + +thermosiphoncoiltypeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONCOILTYPEHEATEXCHANGERS + + +thermosiphonsealedtubeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONSEALEDTUBEHEATEXCHANGERS + + +twintowerenthalpyrecoveryloops = IfcAirToAirHeatRecoveryTypeEnum.TWINTOWERENTHALPYRECOVERYLOOPS + + +userdefined = IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED + + +notdefined = IfcAirToAirHeatRecoveryTypeEnum.NOTDEFINED + + +IfcAlarmTypeEnum = enum_namespace() + + +bell = IfcAlarmTypeEnum.BELL + + +breakglassbutton = IfcAlarmTypeEnum.BREAKGLASSBUTTON + + +light = IfcAlarmTypeEnum.LIGHT + + +manualpullbox = IfcAlarmTypeEnum.MANUALPULLBOX + + +railwaycrocodile = IfcAlarmTypeEnum.RAILWAYCROCODILE + + +railwaydetonator = IfcAlarmTypeEnum.RAILWAYDETONATOR + + +siren = IfcAlarmTypeEnum.SIREN + + +whistle = IfcAlarmTypeEnum.WHISTLE + + +userdefined = IfcAlarmTypeEnum.USERDEFINED + + +notdefined = IfcAlarmTypeEnum.NOTDEFINED + + +IfcAlignmentCantSegmentTypeEnum = enum_namespace() + + +blosscurve = IfcAlignmentCantSegmentTypeEnum.BLOSSCURVE + + +constantcant = IfcAlignmentCantSegmentTypeEnum.CONSTANTCANT + + +cosinecurve = IfcAlignmentCantSegmentTypeEnum.COSINECURVE + + +helmertcurve = IfcAlignmentCantSegmentTypeEnum.HELMERTCURVE + + +lineartransition = IfcAlignmentCantSegmentTypeEnum.LINEARTRANSITION + + +sinecurve = IfcAlignmentCantSegmentTypeEnum.SINECURVE + + +viennesebend = IfcAlignmentCantSegmentTypeEnum.VIENNESEBEND + + +IfcAlignmentHorizontalSegmentTypeEnum = enum_namespace() + + +blosscurve = IfcAlignmentHorizontalSegmentTypeEnum.BLOSSCURVE + + +circulararc = IfcAlignmentHorizontalSegmentTypeEnum.CIRCULARARC + + +clothoid = IfcAlignmentHorizontalSegmentTypeEnum.CLOTHOID + + +cosinecurve = IfcAlignmentHorizontalSegmentTypeEnum.COSINECURVE + + +cubic = IfcAlignmentHorizontalSegmentTypeEnum.CUBIC + + +helmertcurve = IfcAlignmentHorizontalSegmentTypeEnum.HELMERTCURVE + + +line = IfcAlignmentHorizontalSegmentTypeEnum.LINE + + +sinecurve = IfcAlignmentHorizontalSegmentTypeEnum.SINECURVE + + +viennesebend = IfcAlignmentHorizontalSegmentTypeEnum.VIENNESEBEND + + +IfcAlignmentTypeEnum = enum_namespace() + + +userdefined = IfcAlignmentTypeEnum.USERDEFINED + + +notdefined = IfcAlignmentTypeEnum.NOTDEFINED + + +IfcAlignmentVerticalSegmentTypeEnum = enum_namespace() + + +circulararc = IfcAlignmentVerticalSegmentTypeEnum.CIRCULARARC + + +clothoid = IfcAlignmentVerticalSegmentTypeEnum.CLOTHOID + + +constantgradient = IfcAlignmentVerticalSegmentTypeEnum.CONSTANTGRADIENT + + +parabolicarc = IfcAlignmentVerticalSegmentTypeEnum.PARABOLICARC + + +IfcAnalysisModelTypeEnum = enum_namespace() + + +in_plane_loading_2d = IfcAnalysisModelTypeEnum.IN_PLANE_LOADING_2D + + +loading_3d = IfcAnalysisModelTypeEnum.LOADING_3D + + +out_plane_loading_2d = IfcAnalysisModelTypeEnum.OUT_PLANE_LOADING_2D + + +userdefined = IfcAnalysisModelTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisModelTypeEnum.NOTDEFINED + + +IfcAnalysisTheoryTypeEnum = enum_namespace() + + +first_order_theory = IfcAnalysisTheoryTypeEnum.FIRST_ORDER_THEORY + + +full_nonlinear_theory = IfcAnalysisTheoryTypeEnum.FULL_NONLINEAR_THEORY + + +second_order_theory = IfcAnalysisTheoryTypeEnum.SECOND_ORDER_THEORY + + +third_order_theory = IfcAnalysisTheoryTypeEnum.THIRD_ORDER_THEORY + + +userdefined = IfcAnalysisTheoryTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisTheoryTypeEnum.NOTDEFINED + + +IfcAnnotationTypeEnum = enum_namespace() + + +asbuiltarea = IfcAnnotationTypeEnum.ASBUILTAREA + + +asbuiltline = IfcAnnotationTypeEnum.ASBUILTLINE + + +asbuiltpoint = IfcAnnotationTypeEnum.ASBUILTPOINT + + +assumedarea = IfcAnnotationTypeEnum.ASSUMEDAREA + + +assumedline = IfcAnnotationTypeEnum.ASSUMEDLINE + + +assumedpoint = IfcAnnotationTypeEnum.ASSUMEDPOINT + + +non_physical_signal = IfcAnnotationTypeEnum.NON_PHYSICAL_SIGNAL + + +superelevationevent = IfcAnnotationTypeEnum.SUPERELEVATIONEVENT + + +widthevent = IfcAnnotationTypeEnum.WIDTHEVENT + + +userdefined = IfcAnnotationTypeEnum.USERDEFINED + + +notdefined = IfcAnnotationTypeEnum.NOTDEFINED + + +IfcArithmeticOperatorEnum = enum_namespace() + + +add = IfcArithmeticOperatorEnum.ADD + + +divide = IfcArithmeticOperatorEnum.DIVIDE + + +multiply = IfcArithmeticOperatorEnum.MULTIPLY + + +subtract = IfcArithmeticOperatorEnum.SUBTRACT + + +IfcAssemblyPlaceEnum = enum_namespace() + + +factory = IfcAssemblyPlaceEnum.FACTORY + + +site = IfcAssemblyPlaceEnum.SITE + + +notdefined = IfcAssemblyPlaceEnum.NOTDEFINED + + +IfcAudioVisualApplianceTypeEnum = enum_namespace() + + +amplifier = IfcAudioVisualApplianceTypeEnum.AMPLIFIER + + +camera = IfcAudioVisualApplianceTypeEnum.CAMERA + + +communicationterminal = IfcAudioVisualApplianceTypeEnum.COMMUNICATIONTERMINAL + + +display = IfcAudioVisualApplianceTypeEnum.DISPLAY + + +microphone = IfcAudioVisualApplianceTypeEnum.MICROPHONE + + +player = IfcAudioVisualApplianceTypeEnum.PLAYER + + +projector = IfcAudioVisualApplianceTypeEnum.PROJECTOR + + +receiver = IfcAudioVisualApplianceTypeEnum.RECEIVER + + +recordingequipment = IfcAudioVisualApplianceTypeEnum.RECORDINGEQUIPMENT + + +speaker = IfcAudioVisualApplianceTypeEnum.SPEAKER + + +switcher = IfcAudioVisualApplianceTypeEnum.SWITCHER + + +telephone = IfcAudioVisualApplianceTypeEnum.TELEPHONE + + +tuner = IfcAudioVisualApplianceTypeEnum.TUNER + + +userdefined = IfcAudioVisualApplianceTypeEnum.USERDEFINED + + +notdefined = IfcAudioVisualApplianceTypeEnum.NOTDEFINED + + +IfcBSplineCurveForm = enum_namespace() + + +circular_arc = IfcBSplineCurveForm.CIRCULAR_ARC + + +elliptic_arc = IfcBSplineCurveForm.ELLIPTIC_ARC + + +hyperbolic_arc = IfcBSplineCurveForm.HYPERBOLIC_ARC + + +parabolic_arc = IfcBSplineCurveForm.PARABOLIC_ARC + + +polyline_form = IfcBSplineCurveForm.POLYLINE_FORM + + +unspecified = IfcBSplineCurveForm.UNSPECIFIED + + +IfcBSplineSurfaceForm = enum_namespace() + + +conical_surf = IfcBSplineSurfaceForm.CONICAL_SURF + + +cylindrical_surf = IfcBSplineSurfaceForm.CYLINDRICAL_SURF + + +generalised_cone = IfcBSplineSurfaceForm.GENERALISED_CONE + + +plane_surf = IfcBSplineSurfaceForm.PLANE_SURF + + +quadric_surf = IfcBSplineSurfaceForm.QUADRIC_SURF + + +ruled_surf = IfcBSplineSurfaceForm.RULED_SURF + + +spherical_surf = IfcBSplineSurfaceForm.SPHERICAL_SURF + + +surf_of_linear_extrusion = IfcBSplineSurfaceForm.SURF_OF_LINEAR_EXTRUSION + + +surf_of_revolution = IfcBSplineSurfaceForm.SURF_OF_REVOLUTION + + +toroidal_surf = IfcBSplineSurfaceForm.TOROIDAL_SURF + + +unspecified = IfcBSplineSurfaceForm.UNSPECIFIED + + +IfcBeamTypeEnum = enum_namespace() + + +beam = IfcBeamTypeEnum.BEAM + + +cornice = IfcBeamTypeEnum.CORNICE + + +diaphragm = IfcBeamTypeEnum.DIAPHRAGM + + +edgebeam = IfcBeamTypeEnum.EDGEBEAM + + +girder_segment = IfcBeamTypeEnum.GIRDER_SEGMENT + + +hatstone = IfcBeamTypeEnum.HATSTONE + + +hollowcore = IfcBeamTypeEnum.HOLLOWCORE + + +joist = IfcBeamTypeEnum.JOIST + + +lintel = IfcBeamTypeEnum.LINTEL + + +piercap = IfcBeamTypeEnum.PIERCAP + + +spandrel = IfcBeamTypeEnum.SPANDREL + + +t_beam = IfcBeamTypeEnum.T_BEAM + + +userdefined = IfcBeamTypeEnum.USERDEFINED + + +notdefined = IfcBeamTypeEnum.NOTDEFINED + + +IfcBearingTypeEnum = enum_namespace() + + +cylindrical = IfcBearingTypeEnum.CYLINDRICAL + + +disk = IfcBearingTypeEnum.DISK + + +elastomeric = IfcBearingTypeEnum.ELASTOMERIC + + +guide = IfcBearingTypeEnum.GUIDE + + +pot = IfcBearingTypeEnum.POT + + +rocker = IfcBearingTypeEnum.ROCKER + + +roller = IfcBearingTypeEnum.ROLLER + + +spherical = IfcBearingTypeEnum.SPHERICAL + + +userdefined = IfcBearingTypeEnum.USERDEFINED + + +notdefined = IfcBearingTypeEnum.NOTDEFINED + + +IfcBenchmarkEnum = enum_namespace() + + +equalto = IfcBenchmarkEnum.EQUALTO + + +greaterthan = IfcBenchmarkEnum.GREATERTHAN + + +greaterthanorequalto = IfcBenchmarkEnum.GREATERTHANOREQUALTO + + +includedin = IfcBenchmarkEnum.INCLUDEDIN + + +includes = IfcBenchmarkEnum.INCLUDES + + +lessthan = IfcBenchmarkEnum.LESSTHAN + + +lessthanorequalto = IfcBenchmarkEnum.LESSTHANOREQUALTO + + +notequalto = IfcBenchmarkEnum.NOTEQUALTO + + +notincludedin = IfcBenchmarkEnum.NOTINCLUDEDIN + + +notincludes = IfcBenchmarkEnum.NOTINCLUDES + + +IfcBoilerTypeEnum = enum_namespace() + + +steam = IfcBoilerTypeEnum.STEAM + + +water = IfcBoilerTypeEnum.WATER + + +userdefined = IfcBoilerTypeEnum.USERDEFINED + + +notdefined = IfcBoilerTypeEnum.NOTDEFINED + + +IfcBooleanOperator = enum_namespace() + + +difference = IfcBooleanOperator.DIFFERENCE + + +intersection = IfcBooleanOperator.INTERSECTION + + +union = IfcBooleanOperator.UNION + + +IfcBridgePartTypeEnum = enum_namespace() + + +abutment = IfcBridgePartTypeEnum.ABUTMENT + + +deck = IfcBridgePartTypeEnum.DECK + + +deck_segment = IfcBridgePartTypeEnum.DECK_SEGMENT + + +foundation = IfcBridgePartTypeEnum.FOUNDATION + + +pier = IfcBridgePartTypeEnum.PIER + + +pier_segment = IfcBridgePartTypeEnum.PIER_SEGMENT + + +pylon = IfcBridgePartTypeEnum.PYLON + + +substructure = IfcBridgePartTypeEnum.SUBSTRUCTURE + + +superstructure = IfcBridgePartTypeEnum.SUPERSTRUCTURE + + +surfacestructure = IfcBridgePartTypeEnum.SURFACESTRUCTURE + + +userdefined = IfcBridgePartTypeEnum.USERDEFINED + + +notdefined = IfcBridgePartTypeEnum.NOTDEFINED + + +IfcBridgeTypeEnum = enum_namespace() + + +arched = IfcBridgeTypeEnum.ARCHED + + +cable_stayed = IfcBridgeTypeEnum.CABLE_STAYED + + +cantilever = IfcBridgeTypeEnum.CANTILEVER + + +culvert = IfcBridgeTypeEnum.CULVERT + + +framework = IfcBridgeTypeEnum.FRAMEWORK + + +girder = IfcBridgeTypeEnum.GIRDER + + +suspension = IfcBridgeTypeEnum.SUSPENSION + + +truss = IfcBridgeTypeEnum.TRUSS + + +userdefined = IfcBridgeTypeEnum.USERDEFINED + + +notdefined = IfcBridgeTypeEnum.NOTDEFINED + + +IfcBuildingElementPartTypeEnum = enum_namespace() + + +apron = IfcBuildingElementPartTypeEnum.APRON + + +armourunit = IfcBuildingElementPartTypeEnum.ARMOURUNIT + + +insulation = IfcBuildingElementPartTypeEnum.INSULATION + + +precastpanel = IfcBuildingElementPartTypeEnum.PRECASTPANEL + + +safetycage = IfcBuildingElementPartTypeEnum.SAFETYCAGE + + +userdefined = IfcBuildingElementPartTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementPartTypeEnum.NOTDEFINED + + +IfcBuildingElementProxyTypeEnum = enum_namespace() + + +complex = IfcBuildingElementProxyTypeEnum.COMPLEX + + +element = IfcBuildingElementProxyTypeEnum.ELEMENT + + +partial = IfcBuildingElementProxyTypeEnum.PARTIAL + + +provisionforspace = IfcBuildingElementProxyTypeEnum.PROVISIONFORSPACE + + +provisionforvoid = IfcBuildingElementProxyTypeEnum.PROVISIONFORVOID + + +userdefined = IfcBuildingElementProxyTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementProxyTypeEnum.NOTDEFINED + + +IfcBuildingSystemTypeEnum = enum_namespace() + + +fenestration = IfcBuildingSystemTypeEnum.FENESTRATION + + +foundation = IfcBuildingSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuildingSystemTypeEnum.LOADBEARING + + +outershell = IfcBuildingSystemTypeEnum.OUTERSHELL + + +shading = IfcBuildingSystemTypeEnum.SHADING + + +transport = IfcBuildingSystemTypeEnum.TRANSPORT + + +userdefined = IfcBuildingSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuildingSystemTypeEnum.NOTDEFINED + + +IfcBuiltSystemTypeEnum = enum_namespace() + + +erosionprevention = IfcBuiltSystemTypeEnum.EROSIONPREVENTION + + +fenestration = IfcBuiltSystemTypeEnum.FENESTRATION + + +foundation = IfcBuiltSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuiltSystemTypeEnum.LOADBEARING + + +mooring = IfcBuiltSystemTypeEnum.MOORING + + +outershell = IfcBuiltSystemTypeEnum.OUTERSHELL + + +prestressing = IfcBuiltSystemTypeEnum.PRESTRESSING + + +railwayline = IfcBuiltSystemTypeEnum.RAILWAYLINE + + +railwaytrack = IfcBuiltSystemTypeEnum.RAILWAYTRACK + + +reinforcing = IfcBuiltSystemTypeEnum.REINFORCING + + +shading = IfcBuiltSystemTypeEnum.SHADING + + +trackcircuit = IfcBuiltSystemTypeEnum.TRACKCIRCUIT + + +transport = IfcBuiltSystemTypeEnum.TRANSPORT + + +userdefined = IfcBuiltSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuiltSystemTypeEnum.NOTDEFINED + + +IfcBurnerTypeEnum = enum_namespace() + + +userdefined = IfcBurnerTypeEnum.USERDEFINED + + +notdefined = IfcBurnerTypeEnum.NOTDEFINED + + +IfcCableCarrierFittingTypeEnum = enum_namespace() + + +bend = IfcCableCarrierFittingTypeEnum.BEND + + +connector = IfcCableCarrierFittingTypeEnum.CONNECTOR + + +cross = IfcCableCarrierFittingTypeEnum.CROSS + + +junction = IfcCableCarrierFittingTypeEnum.JUNCTION + + +reducer = IfcCableCarrierFittingTypeEnum.REDUCER + + +tee = IfcCableCarrierFittingTypeEnum.TEE + + +transition = IfcCableCarrierFittingTypeEnum.TRANSITION + + +userdefined = IfcCableCarrierFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierFittingTypeEnum.NOTDEFINED + + +IfcCableCarrierSegmentTypeEnum = enum_namespace() + + +cablebracket = IfcCableCarrierSegmentTypeEnum.CABLEBRACKET + + +cableladdersegment = IfcCableCarrierSegmentTypeEnum.CABLELADDERSEGMENT + + +cabletraysegment = IfcCableCarrierSegmentTypeEnum.CABLETRAYSEGMENT + + +cabletrunkingsegment = IfcCableCarrierSegmentTypeEnum.CABLETRUNKINGSEGMENT + + +catenarywire = IfcCableCarrierSegmentTypeEnum.CATENARYWIRE + + +conduitsegment = IfcCableCarrierSegmentTypeEnum.CONDUITSEGMENT + + +dropper = IfcCableCarrierSegmentTypeEnum.DROPPER + + +userdefined = IfcCableCarrierSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierSegmentTypeEnum.NOTDEFINED + + +IfcCableFittingTypeEnum = enum_namespace() + + +connector = IfcCableFittingTypeEnum.CONNECTOR + + +entry = IfcCableFittingTypeEnum.ENTRY + + +exit = IfcCableFittingTypeEnum.EXIT + + +fanout = IfcCableFittingTypeEnum.FANOUT + + +junction = IfcCableFittingTypeEnum.JUNCTION + + +transition = IfcCableFittingTypeEnum.TRANSITION + + +userdefined = IfcCableFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableFittingTypeEnum.NOTDEFINED + + +IfcCableSegmentTypeEnum = enum_namespace() + + +busbarsegment = IfcCableSegmentTypeEnum.BUSBARSEGMENT + + +cablesegment = IfcCableSegmentTypeEnum.CABLESEGMENT + + +conductorsegment = IfcCableSegmentTypeEnum.CONDUCTORSEGMENT + + +contactwiresegment = IfcCableSegmentTypeEnum.CONTACTWIRESEGMENT + + +coresegment = IfcCableSegmentTypeEnum.CORESEGMENT + + +fibersegment = IfcCableSegmentTypeEnum.FIBERSEGMENT + + +fibertube = IfcCableSegmentTypeEnum.FIBERTUBE + + +opticalcablesegment = IfcCableSegmentTypeEnum.OPTICALCABLESEGMENT + + +stitchwire = IfcCableSegmentTypeEnum.STITCHWIRE + + +wirepairsegment = IfcCableSegmentTypeEnum.WIREPAIRSEGMENT + + +userdefined = IfcCableSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableSegmentTypeEnum.NOTDEFINED + + +IfcCaissonFoundationTypeEnum = enum_namespace() + + +caisson = IfcCaissonFoundationTypeEnum.CAISSON + + +well = IfcCaissonFoundationTypeEnum.WELL + + +userdefined = IfcCaissonFoundationTypeEnum.USERDEFINED + + +notdefined = IfcCaissonFoundationTypeEnum.NOTDEFINED + + +IfcChangeActionEnum = enum_namespace() + + +added = IfcChangeActionEnum.ADDED + + +deleted = IfcChangeActionEnum.DELETED + + +modified = IfcChangeActionEnum.MODIFIED + + +nochange = IfcChangeActionEnum.NOCHANGE + + +notdefined = IfcChangeActionEnum.NOTDEFINED + + +IfcChillerTypeEnum = enum_namespace() + + +aircooled = IfcChillerTypeEnum.AIRCOOLED + + +heatrecovery = IfcChillerTypeEnum.HEATRECOVERY + + +watercooled = IfcChillerTypeEnum.WATERCOOLED + + +userdefined = IfcChillerTypeEnum.USERDEFINED + + +notdefined = IfcChillerTypeEnum.NOTDEFINED + + +IfcChimneyTypeEnum = enum_namespace() + + +userdefined = IfcChimneyTypeEnum.USERDEFINED + + +notdefined = IfcChimneyTypeEnum.NOTDEFINED + + +IfcCoilTypeEnum = enum_namespace() + + +dxcoolingcoil = IfcCoilTypeEnum.DXCOOLINGCOIL + + +electricheatingcoil = IfcCoilTypeEnum.ELECTRICHEATINGCOIL + + +gasheatingcoil = IfcCoilTypeEnum.GASHEATINGCOIL + + +hydroniccoil = IfcCoilTypeEnum.HYDRONICCOIL + + +steamheatingcoil = IfcCoilTypeEnum.STEAMHEATINGCOIL + + +watercoolingcoil = IfcCoilTypeEnum.WATERCOOLINGCOIL + + +waterheatingcoil = IfcCoilTypeEnum.WATERHEATINGCOIL + + +userdefined = IfcCoilTypeEnum.USERDEFINED + + +notdefined = IfcCoilTypeEnum.NOTDEFINED + + +IfcColumnTypeEnum = enum_namespace() + + +column = IfcColumnTypeEnum.COLUMN + + +pierstem = IfcColumnTypeEnum.PIERSTEM + + +pierstem_segment = IfcColumnTypeEnum.PIERSTEM_SEGMENT + + +pilaster = IfcColumnTypeEnum.PILASTER + + +standcolumn = IfcColumnTypeEnum.STANDCOLUMN + + +userdefined = IfcColumnTypeEnum.USERDEFINED + + +notdefined = IfcColumnTypeEnum.NOTDEFINED + + +IfcCommunicationsApplianceTypeEnum = enum_namespace() + + +antenna = IfcCommunicationsApplianceTypeEnum.ANTENNA + + +automaton = IfcCommunicationsApplianceTypeEnum.AUTOMATON + + +computer = IfcCommunicationsApplianceTypeEnum.COMPUTER + + +fax = IfcCommunicationsApplianceTypeEnum.FAX + + +gateway = IfcCommunicationsApplianceTypeEnum.GATEWAY + + +intelligentperipheral = IfcCommunicationsApplianceTypeEnum.INTELLIGENTPERIPHERAL + + +ipnetworkequipment = IfcCommunicationsApplianceTypeEnum.IPNETWORKEQUIPMENT + + +linesideelectronicunit = IfcCommunicationsApplianceTypeEnum.LINESIDEELECTRONICUNIT + + +modem = IfcCommunicationsApplianceTypeEnum.MODEM + + +networkappliance = IfcCommunicationsApplianceTypeEnum.NETWORKAPPLIANCE + + +networkbridge = IfcCommunicationsApplianceTypeEnum.NETWORKBRIDGE + + +networkhub = IfcCommunicationsApplianceTypeEnum.NETWORKHUB + + +opticallineterminal = IfcCommunicationsApplianceTypeEnum.OPTICALLINETERMINAL + + +opticalnetworkunit = IfcCommunicationsApplianceTypeEnum.OPTICALNETWORKUNIT + + +printer = IfcCommunicationsApplianceTypeEnum.PRINTER + + +radioblockcenter = IfcCommunicationsApplianceTypeEnum.RADIOBLOCKCENTER + + +repeater = IfcCommunicationsApplianceTypeEnum.REPEATER + + +router = IfcCommunicationsApplianceTypeEnum.ROUTER + + +scanner = IfcCommunicationsApplianceTypeEnum.SCANNER + + +telecommand = IfcCommunicationsApplianceTypeEnum.TELECOMMAND + + +telephonyexchange = IfcCommunicationsApplianceTypeEnum.TELEPHONYEXCHANGE + + +transitioncomponent = IfcCommunicationsApplianceTypeEnum.TRANSITIONCOMPONENT + + +transponder = IfcCommunicationsApplianceTypeEnum.TRANSPONDER + + +transportequipment = IfcCommunicationsApplianceTypeEnum.TRANSPORTEQUIPMENT + + +userdefined = IfcCommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcCommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcComplexPropertyTemplateTypeEnum = enum_namespace() + + +p_complex = IfcComplexPropertyTemplateTypeEnum.P_COMPLEX + + +q_complex = IfcComplexPropertyTemplateTypeEnum.Q_COMPLEX + + +IfcCompressorTypeEnum = enum_namespace() + + +booster = IfcCompressorTypeEnum.BOOSTER + + +dynamic = IfcCompressorTypeEnum.DYNAMIC + + +hermetic = IfcCompressorTypeEnum.HERMETIC + + +opentype = IfcCompressorTypeEnum.OPENTYPE + + +reciprocating = IfcCompressorTypeEnum.RECIPROCATING + + +rollingpiston = IfcCompressorTypeEnum.ROLLINGPISTON + + +rotary = IfcCompressorTypeEnum.ROTARY + + +rotaryvane = IfcCompressorTypeEnum.ROTARYVANE + + +scroll = IfcCompressorTypeEnum.SCROLL + + +semihermetic = IfcCompressorTypeEnum.SEMIHERMETIC + + +singlescrew = IfcCompressorTypeEnum.SINGLESCREW + + +singlestage = IfcCompressorTypeEnum.SINGLESTAGE + + +trochoidal = IfcCompressorTypeEnum.TROCHOIDAL + + +twinscrew = IfcCompressorTypeEnum.TWINSCREW + + +weldedshellhermetic = IfcCompressorTypeEnum.WELDEDSHELLHERMETIC + + +userdefined = IfcCompressorTypeEnum.USERDEFINED + + +notdefined = IfcCompressorTypeEnum.NOTDEFINED + + +IfcCondenserTypeEnum = enum_namespace() + + +aircooled = IfcCondenserTypeEnum.AIRCOOLED + + +evaporativecooled = IfcCondenserTypeEnum.EVAPORATIVECOOLED + + +watercooled = IfcCondenserTypeEnum.WATERCOOLED + + +watercooledbrazedplate = IfcCondenserTypeEnum.WATERCOOLEDBRAZEDPLATE + + +watercooledshellcoil = IfcCondenserTypeEnum.WATERCOOLEDSHELLCOIL + + +watercooledshelltube = IfcCondenserTypeEnum.WATERCOOLEDSHELLTUBE + + +watercooledtubeintube = IfcCondenserTypeEnum.WATERCOOLEDTUBEINTUBE + + +userdefined = IfcCondenserTypeEnum.USERDEFINED + + +notdefined = IfcCondenserTypeEnum.NOTDEFINED + + +IfcConnectionTypeEnum = enum_namespace() + + +atend = IfcConnectionTypeEnum.ATEND + + +atpath = IfcConnectionTypeEnum.ATPATH + + +atstart = IfcConnectionTypeEnum.ATSTART + + +notdefined = IfcConnectionTypeEnum.NOTDEFINED + + +IfcConstraintEnum = enum_namespace() + + +advisory = IfcConstraintEnum.ADVISORY + + +hard = IfcConstraintEnum.HARD + + +soft = IfcConstraintEnum.SOFT + + +userdefined = IfcConstraintEnum.USERDEFINED + + +notdefined = IfcConstraintEnum.NOTDEFINED + + +IfcConstructionEquipmentResourceTypeEnum = enum_namespace() + + +demolishing = IfcConstructionEquipmentResourceTypeEnum.DEMOLISHING + + +earthmoving = IfcConstructionEquipmentResourceTypeEnum.EARTHMOVING + + +erecting = IfcConstructionEquipmentResourceTypeEnum.ERECTING + + +heating = IfcConstructionEquipmentResourceTypeEnum.HEATING + + +lighting = IfcConstructionEquipmentResourceTypeEnum.LIGHTING + + +paving = IfcConstructionEquipmentResourceTypeEnum.PAVING + + +pumping = IfcConstructionEquipmentResourceTypeEnum.PUMPING + + +transporting = IfcConstructionEquipmentResourceTypeEnum.TRANSPORTING + + +userdefined = IfcConstructionEquipmentResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionEquipmentResourceTypeEnum.NOTDEFINED + + +IfcConstructionMaterialResourceTypeEnum = enum_namespace() + + +aggregates = IfcConstructionMaterialResourceTypeEnum.AGGREGATES + + +concrete = IfcConstructionMaterialResourceTypeEnum.CONCRETE + + +drywall = IfcConstructionMaterialResourceTypeEnum.DRYWALL + + +fuel = IfcConstructionMaterialResourceTypeEnum.FUEL + + +gypsum = IfcConstructionMaterialResourceTypeEnum.GYPSUM + + +masonry = IfcConstructionMaterialResourceTypeEnum.MASONRY + + +metal = IfcConstructionMaterialResourceTypeEnum.METAL + + +plastic = IfcConstructionMaterialResourceTypeEnum.PLASTIC + + +wood = IfcConstructionMaterialResourceTypeEnum.WOOD + + +userdefined = IfcConstructionMaterialResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionMaterialResourceTypeEnum.NOTDEFINED + + +IfcConstructionProductResourceTypeEnum = enum_namespace() + + +assembly = IfcConstructionProductResourceTypeEnum.ASSEMBLY + + +formwork = IfcConstructionProductResourceTypeEnum.FORMWORK + + +userdefined = IfcConstructionProductResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionProductResourceTypeEnum.NOTDEFINED + + +IfcControllerTypeEnum = enum_namespace() + + +floating = IfcControllerTypeEnum.FLOATING + + +multiposition = IfcControllerTypeEnum.MULTIPOSITION + + +programmable = IfcControllerTypeEnum.PROGRAMMABLE + + +proportional = IfcControllerTypeEnum.PROPORTIONAL + + +twoposition = IfcControllerTypeEnum.TWOPOSITION + + +userdefined = IfcControllerTypeEnum.USERDEFINED + + +notdefined = IfcControllerTypeEnum.NOTDEFINED + + +IfcConveyorSegmentTypeEnum = enum_namespace() + + +beltconveyor = IfcConveyorSegmentTypeEnum.BELTCONVEYOR + + +bucketconveyor = IfcConveyorSegmentTypeEnum.BUCKETCONVEYOR + + +chuteconveyor = IfcConveyorSegmentTypeEnum.CHUTECONVEYOR + + +screwconveyor = IfcConveyorSegmentTypeEnum.SCREWCONVEYOR + + +userdefined = IfcConveyorSegmentTypeEnum.USERDEFINED + + +notdefined = IfcConveyorSegmentTypeEnum.NOTDEFINED + + +IfcCooledBeamTypeEnum = enum_namespace() + + +active = IfcCooledBeamTypeEnum.ACTIVE + + +passive = IfcCooledBeamTypeEnum.PASSIVE + + +userdefined = IfcCooledBeamTypeEnum.USERDEFINED + + +notdefined = IfcCooledBeamTypeEnum.NOTDEFINED + + +IfcCoolingTowerTypeEnum = enum_namespace() + + +mechanicalforceddraft = IfcCoolingTowerTypeEnum.MECHANICALFORCEDDRAFT + + +mechanicalinduceddraft = IfcCoolingTowerTypeEnum.MECHANICALINDUCEDDRAFT + + +naturaldraft = IfcCoolingTowerTypeEnum.NATURALDRAFT + + +userdefined = IfcCoolingTowerTypeEnum.USERDEFINED + + +notdefined = IfcCoolingTowerTypeEnum.NOTDEFINED + + +IfcCostItemTypeEnum = enum_namespace() + + +userdefined = IfcCostItemTypeEnum.USERDEFINED + + +notdefined = IfcCostItemTypeEnum.NOTDEFINED + + +IfcCostScheduleTypeEnum = enum_namespace() + + +budget = IfcCostScheduleTypeEnum.BUDGET + + +costplan = IfcCostScheduleTypeEnum.COSTPLAN + + +estimate = IfcCostScheduleTypeEnum.ESTIMATE + + +pricedbillofquantities = IfcCostScheduleTypeEnum.PRICEDBILLOFQUANTITIES + + +scheduleofrates = IfcCostScheduleTypeEnum.SCHEDULEOFRATES + + +tender = IfcCostScheduleTypeEnum.TENDER + + +unpricedbillofquantities = IfcCostScheduleTypeEnum.UNPRICEDBILLOFQUANTITIES + + +userdefined = IfcCostScheduleTypeEnum.USERDEFINED + + +notdefined = IfcCostScheduleTypeEnum.NOTDEFINED + + +IfcCourseTypeEnum = enum_namespace() + + +armour = IfcCourseTypeEnum.ARMOUR + + +ballastbed = IfcCourseTypeEnum.BALLASTBED + + +core = IfcCourseTypeEnum.CORE + + +filter = IfcCourseTypeEnum.FILTER + + +pavement = IfcCourseTypeEnum.PAVEMENT + + +protection = IfcCourseTypeEnum.PROTECTION + + +userdefined = IfcCourseTypeEnum.USERDEFINED + + +notdefined = IfcCourseTypeEnum.NOTDEFINED + + +IfcCoveringTypeEnum = enum_namespace() + + +ceiling = IfcCoveringTypeEnum.CEILING + + +cladding = IfcCoveringTypeEnum.CLADDING + + +coping = IfcCoveringTypeEnum.COPING + + +flooring = IfcCoveringTypeEnum.FLOORING + + +insulation = IfcCoveringTypeEnum.INSULATION + + +membrane = IfcCoveringTypeEnum.MEMBRANE + + +molding = IfcCoveringTypeEnum.MOLDING + + +roofing = IfcCoveringTypeEnum.ROOFING + + +skirtingboard = IfcCoveringTypeEnum.SKIRTINGBOARD + + +sleeving = IfcCoveringTypeEnum.SLEEVING + + +topping = IfcCoveringTypeEnum.TOPPING + + +wrapping = IfcCoveringTypeEnum.WRAPPING + + +userdefined = IfcCoveringTypeEnum.USERDEFINED + + +notdefined = IfcCoveringTypeEnum.NOTDEFINED + + +IfcCrewResourceTypeEnum = enum_namespace() + + +office = IfcCrewResourceTypeEnum.OFFICE + + +site = IfcCrewResourceTypeEnum.SITE + + +userdefined = IfcCrewResourceTypeEnum.USERDEFINED + + +notdefined = IfcCrewResourceTypeEnum.NOTDEFINED + + +IfcCurtainWallTypeEnum = enum_namespace() + + +userdefined = IfcCurtainWallTypeEnum.USERDEFINED + + +notdefined = IfcCurtainWallTypeEnum.NOTDEFINED + + +IfcCurveInterpolationEnum = enum_namespace() + + +linear = IfcCurveInterpolationEnum.LINEAR + + +log_linear = IfcCurveInterpolationEnum.LOG_LINEAR + + +log_log = IfcCurveInterpolationEnum.LOG_LOG + + +notdefined = IfcCurveInterpolationEnum.NOTDEFINED + + +IfcDamperTypeEnum = enum_namespace() + + +backdraftdamper = IfcDamperTypeEnum.BACKDRAFTDAMPER + + +balancingdamper = IfcDamperTypeEnum.BALANCINGDAMPER + + +blastdamper = IfcDamperTypeEnum.BLASTDAMPER + + +controldamper = IfcDamperTypeEnum.CONTROLDAMPER + + +firedamper = IfcDamperTypeEnum.FIREDAMPER + + +firesmokedamper = IfcDamperTypeEnum.FIRESMOKEDAMPER + + +fumehoodexhaust = IfcDamperTypeEnum.FUMEHOODEXHAUST + + +gravitydamper = IfcDamperTypeEnum.GRAVITYDAMPER + + +gravityreliefdamper = IfcDamperTypeEnum.GRAVITYRELIEFDAMPER + + +reliefdamper = IfcDamperTypeEnum.RELIEFDAMPER + + +smokedamper = IfcDamperTypeEnum.SMOKEDAMPER + + +userdefined = IfcDamperTypeEnum.USERDEFINED + + +notdefined = IfcDamperTypeEnum.NOTDEFINED + + +IfcDataOriginEnum = enum_namespace() + + +measured = IfcDataOriginEnum.MEASURED + + +predicted = IfcDataOriginEnum.PREDICTED + + +simulated = IfcDataOriginEnum.SIMULATED + + +userdefined = IfcDataOriginEnum.USERDEFINED + + +notdefined = IfcDataOriginEnum.NOTDEFINED + + +IfcDerivedUnitEnum = enum_namespace() + + +accelerationunit = IfcDerivedUnitEnum.ACCELERATIONUNIT + + +angularvelocityunit = IfcDerivedUnitEnum.ANGULARVELOCITYUNIT + + +areadensityunit = IfcDerivedUnitEnum.AREADENSITYUNIT + + +compoundplaneangleunit = IfcDerivedUnitEnum.COMPOUNDPLANEANGLEUNIT + + +curvatureunit = IfcDerivedUnitEnum.CURVATUREUNIT + + +dynamicviscosityunit = IfcDerivedUnitEnum.DYNAMICVISCOSITYUNIT + + +heatfluxdensityunit = IfcDerivedUnitEnum.HEATFLUXDENSITYUNIT + + +heatingvalueunit = IfcDerivedUnitEnum.HEATINGVALUEUNIT + + +integercountrateunit = IfcDerivedUnitEnum.INTEGERCOUNTRATEUNIT + + +ionconcentrationunit = IfcDerivedUnitEnum.IONCONCENTRATIONUNIT + + +isothermalmoisturecapacityunit = IfcDerivedUnitEnum.ISOTHERMALMOISTURECAPACITYUNIT + + +kinematicviscosityunit = IfcDerivedUnitEnum.KINEMATICVISCOSITYUNIT + + +linearforceunit = IfcDerivedUnitEnum.LINEARFORCEUNIT + + +linearmomentunit = IfcDerivedUnitEnum.LINEARMOMENTUNIT + + +linearstiffnessunit = IfcDerivedUnitEnum.LINEARSTIFFNESSUNIT + + +linearvelocityunit = IfcDerivedUnitEnum.LINEARVELOCITYUNIT + + +luminousintensitydistributionunit = IfcDerivedUnitEnum.LUMINOUSINTENSITYDISTRIBUTIONUNIT + + +massdensityunit = IfcDerivedUnitEnum.MASSDENSITYUNIT + + +massflowrateunit = IfcDerivedUnitEnum.MASSFLOWRATEUNIT + + +massperlengthunit = IfcDerivedUnitEnum.MASSPERLENGTHUNIT + + +modulusofelasticityunit = IfcDerivedUnitEnum.MODULUSOFELASTICITYUNIT + + +modulusoflinearsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFLINEARSUBGRADEREACTIONUNIT + + +modulusofrotationalsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFROTATIONALSUBGRADEREACTIONUNIT + + +modulusofsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFSUBGRADEREACTIONUNIT + + +moisturediffusivityunit = IfcDerivedUnitEnum.MOISTUREDIFFUSIVITYUNIT + + +molecularweightunit = IfcDerivedUnitEnum.MOLECULARWEIGHTUNIT + + +momentofinertiaunit = IfcDerivedUnitEnum.MOMENTOFINERTIAUNIT + + +phunit = IfcDerivedUnitEnum.PHUNIT + + +planarforceunit = IfcDerivedUnitEnum.PLANARFORCEUNIT + + +rotationalfrequencyunit = IfcDerivedUnitEnum.ROTATIONALFREQUENCYUNIT + + +rotationalmassunit = IfcDerivedUnitEnum.ROTATIONALMASSUNIT + + +rotationalstiffnessunit = IfcDerivedUnitEnum.ROTATIONALSTIFFNESSUNIT + + +sectionareaintegralunit = IfcDerivedUnitEnum.SECTIONAREAINTEGRALUNIT + + +sectionmodulusunit = IfcDerivedUnitEnum.SECTIONMODULUSUNIT + + +shearmodulusunit = IfcDerivedUnitEnum.SHEARMODULUSUNIT + + +soundpowerlevelunit = IfcDerivedUnitEnum.SOUNDPOWERLEVELUNIT + + +soundpowerunit = IfcDerivedUnitEnum.SOUNDPOWERUNIT + + +soundpressurelevelunit = IfcDerivedUnitEnum.SOUNDPRESSURELEVELUNIT + + +soundpressureunit = IfcDerivedUnitEnum.SOUNDPRESSUREUNIT + + +specificheatcapacityunit = IfcDerivedUnitEnum.SPECIFICHEATCAPACITYUNIT + + +temperaturegradientunit = IfcDerivedUnitEnum.TEMPERATUREGRADIENTUNIT + + +temperaturerateofchangeunit = IfcDerivedUnitEnum.TEMPERATURERATEOFCHANGEUNIT + + +thermaladmittanceunit = IfcDerivedUnitEnum.THERMALADMITTANCEUNIT + + +thermalconductanceunit = IfcDerivedUnitEnum.THERMALCONDUCTANCEUNIT + + +thermalexpansioncoefficientunit = IfcDerivedUnitEnum.THERMALEXPANSIONCOEFFICIENTUNIT + + +thermalresistanceunit = IfcDerivedUnitEnum.THERMALRESISTANCEUNIT + + +thermaltransmittanceunit = IfcDerivedUnitEnum.THERMALTRANSMITTANCEUNIT + + +torqueunit = IfcDerivedUnitEnum.TORQUEUNIT + + +vaporpermeabilityunit = IfcDerivedUnitEnum.VAPORPERMEABILITYUNIT + + +volumetricflowrateunit = IfcDerivedUnitEnum.VOLUMETRICFLOWRATEUNIT + + +warpingconstantunit = IfcDerivedUnitEnum.WARPINGCONSTANTUNIT + + +warpingmomentunit = IfcDerivedUnitEnum.WARPINGMOMENTUNIT + + +userdefined = IfcDerivedUnitEnum.USERDEFINED + + +IfcDirectionSenseEnum = enum_namespace() + + +negative = IfcDirectionSenseEnum.NEGATIVE + + +positive = IfcDirectionSenseEnum.POSITIVE + + +IfcDiscreteAccessoryTypeEnum = enum_namespace() + + +anchorplate = IfcDiscreteAccessoryTypeEnum.ANCHORPLATE + + +birdprotection = IfcDiscreteAccessoryTypeEnum.BIRDPROTECTION + + +bracket = IfcDiscreteAccessoryTypeEnum.BRACKET + + +cablearranger = IfcDiscreteAccessoryTypeEnum.CABLEARRANGER + + +elastic_cushion = IfcDiscreteAccessoryTypeEnum.ELASTIC_CUSHION + + +expansion_joint_device = IfcDiscreteAccessoryTypeEnum.EXPANSION_JOINT_DEVICE + + +filler = IfcDiscreteAccessoryTypeEnum.FILLER + + +flashing = IfcDiscreteAccessoryTypeEnum.FLASHING + + +insulator = IfcDiscreteAccessoryTypeEnum.INSULATOR + + +lock = IfcDiscreteAccessoryTypeEnum.LOCK + + +panel_strengthening = IfcDiscreteAccessoryTypeEnum.PANEL_STRENGTHENING + + +pointmachinemountingdevice = IfcDiscreteAccessoryTypeEnum.POINTMACHINEMOUNTINGDEVICE + + +point_machine_locking_device = IfcDiscreteAccessoryTypeEnum.POINT_MACHINE_LOCKING_DEVICE + + +railbrace = IfcDiscreteAccessoryTypeEnum.RAILBRACE + + +railpad = IfcDiscreteAccessoryTypeEnum.RAILPAD + + +rail_lubrication = IfcDiscreteAccessoryTypeEnum.RAIL_LUBRICATION + + +rail_mechanical_equipment = IfcDiscreteAccessoryTypeEnum.RAIL_MECHANICAL_EQUIPMENT + + +shoe = IfcDiscreteAccessoryTypeEnum.SHOE + + +slidingchair = IfcDiscreteAccessoryTypeEnum.SLIDINGCHAIR + + +soundabsorption = IfcDiscreteAccessoryTypeEnum.SOUNDABSORPTION + + +tensioningequipment = IfcDiscreteAccessoryTypeEnum.TENSIONINGEQUIPMENT + + +userdefined = IfcDiscreteAccessoryTypeEnum.USERDEFINED + + +notdefined = IfcDiscreteAccessoryTypeEnum.NOTDEFINED + + +IfcDistributionBoardTypeEnum = enum_namespace() + + +consumerunit = IfcDistributionBoardTypeEnum.CONSUMERUNIT + + +dispatchingboard = IfcDistributionBoardTypeEnum.DISPATCHINGBOARD + + +distributionboard = IfcDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +distributionframe = IfcDistributionBoardTypeEnum.DISTRIBUTIONFRAME + + +motorcontrolcentre = IfcDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +switchboard = IfcDistributionBoardTypeEnum.SWITCHBOARD + + +userdefined = IfcDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcDistributionBoardTypeEnum.NOTDEFINED + + +IfcDistributionChamberElementTypeEnum = enum_namespace() + + +formedduct = IfcDistributionChamberElementTypeEnum.FORMEDDUCT + + +inspectionchamber = IfcDistributionChamberElementTypeEnum.INSPECTIONCHAMBER + + +inspectionpit = IfcDistributionChamberElementTypeEnum.INSPECTIONPIT + + +manhole = IfcDistributionChamberElementTypeEnum.MANHOLE + + +meterchamber = IfcDistributionChamberElementTypeEnum.METERCHAMBER + + +sump = IfcDistributionChamberElementTypeEnum.SUMP + + +trench = IfcDistributionChamberElementTypeEnum.TRENCH + + +valvechamber = IfcDistributionChamberElementTypeEnum.VALVECHAMBER + + +userdefined = IfcDistributionChamberElementTypeEnum.USERDEFINED + + +notdefined = IfcDistributionChamberElementTypeEnum.NOTDEFINED + + +IfcDistributionPortTypeEnum = enum_namespace() + + +cable = IfcDistributionPortTypeEnum.CABLE + + +cablecarrier = IfcDistributionPortTypeEnum.CABLECARRIER + + +duct = IfcDistributionPortTypeEnum.DUCT + + +pipe = IfcDistributionPortTypeEnum.PIPE + + +wireless = IfcDistributionPortTypeEnum.WIRELESS + + +userdefined = IfcDistributionPortTypeEnum.USERDEFINED + + +notdefined = IfcDistributionPortTypeEnum.NOTDEFINED + + +IfcDistributionSystemEnum = enum_namespace() + + +airconditioning = IfcDistributionSystemEnum.AIRCONDITIONING + + +audiovisual = IfcDistributionSystemEnum.AUDIOVISUAL + + +catenary_system = IfcDistributionSystemEnum.CATENARY_SYSTEM + + +chemical = IfcDistributionSystemEnum.CHEMICAL + + +chilledwater = IfcDistributionSystemEnum.CHILLEDWATER + + +communication = IfcDistributionSystemEnum.COMMUNICATION + + +compressedair = IfcDistributionSystemEnum.COMPRESSEDAIR + + +condenserwater = IfcDistributionSystemEnum.CONDENSERWATER + + +control = IfcDistributionSystemEnum.CONTROL + + +conveying = IfcDistributionSystemEnum.CONVEYING + + +data = IfcDistributionSystemEnum.DATA + + +disposal = IfcDistributionSystemEnum.DISPOSAL + + +domesticcoldwater = IfcDistributionSystemEnum.DOMESTICCOLDWATER + + +domestichotwater = IfcDistributionSystemEnum.DOMESTICHOTWATER + + +drainage = IfcDistributionSystemEnum.DRAINAGE + + +earthing = IfcDistributionSystemEnum.EARTHING + + +electrical = IfcDistributionSystemEnum.ELECTRICAL + + +electroacoustic = IfcDistributionSystemEnum.ELECTROACOUSTIC + + +exhaust = IfcDistributionSystemEnum.EXHAUST + + +fireprotection = IfcDistributionSystemEnum.FIREPROTECTION + + +fixedtransmissionnetwork = IfcDistributionSystemEnum.FIXEDTRANSMISSIONNETWORK + + +fuel = IfcDistributionSystemEnum.FUEL + + +gas = IfcDistributionSystemEnum.GAS + + +hazardous = IfcDistributionSystemEnum.HAZARDOUS + + +heating = IfcDistributionSystemEnum.HEATING + + +lighting = IfcDistributionSystemEnum.LIGHTING + + +lightningprotection = IfcDistributionSystemEnum.LIGHTNINGPROTECTION + + +mobilenetwork = IfcDistributionSystemEnum.MOBILENETWORK + + +monitoringsystem = IfcDistributionSystemEnum.MONITORINGSYSTEM + + +municipalsolidwaste = IfcDistributionSystemEnum.MUNICIPALSOLIDWASTE + + +oil = IfcDistributionSystemEnum.OIL + + +operational = IfcDistributionSystemEnum.OPERATIONAL + + +operationaltelephonysystem = IfcDistributionSystemEnum.OPERATIONALTELEPHONYSYSTEM + + +overhead_contactline_system = IfcDistributionSystemEnum.OVERHEAD_CONTACTLINE_SYSTEM + + +powergeneration = IfcDistributionSystemEnum.POWERGENERATION + + +rainwater = IfcDistributionSystemEnum.RAINWATER + + +refrigeration = IfcDistributionSystemEnum.REFRIGERATION + + +return_circuit = IfcDistributionSystemEnum.RETURN_CIRCUIT + + +security = IfcDistributionSystemEnum.SECURITY + + +sewage = IfcDistributionSystemEnum.SEWAGE + + +signal = IfcDistributionSystemEnum.SIGNAL + + +stormwater = IfcDistributionSystemEnum.STORMWATER + + +telephone = IfcDistributionSystemEnum.TELEPHONE + + +tv = IfcDistributionSystemEnum.TV + + +vacuum = IfcDistributionSystemEnum.VACUUM + + +vent = IfcDistributionSystemEnum.VENT + + +ventilation = IfcDistributionSystemEnum.VENTILATION + + +wastewater = IfcDistributionSystemEnum.WASTEWATER + + +watersupply = IfcDistributionSystemEnum.WATERSUPPLY + + +userdefined = IfcDistributionSystemEnum.USERDEFINED + + +notdefined = IfcDistributionSystemEnum.NOTDEFINED + + +IfcDocumentConfidentialityEnum = enum_namespace() + + +confidential = IfcDocumentConfidentialityEnum.CONFIDENTIAL + + +personal = IfcDocumentConfidentialityEnum.PERSONAL + + +public = IfcDocumentConfidentialityEnum.PUBLIC + + +restricted = IfcDocumentConfidentialityEnum.RESTRICTED + + +userdefined = IfcDocumentConfidentialityEnum.USERDEFINED + + +notdefined = IfcDocumentConfidentialityEnum.NOTDEFINED + + +IfcDocumentStatusEnum = enum_namespace() + + +draft = IfcDocumentStatusEnum.DRAFT + + +final = IfcDocumentStatusEnum.FINAL + + +finaldraft = IfcDocumentStatusEnum.FINALDRAFT + + +revision = IfcDocumentStatusEnum.REVISION + + +notdefined = IfcDocumentStatusEnum.NOTDEFINED + + +IfcDoorPanelOperationEnum = enum_namespace() + + +double_acting = IfcDoorPanelOperationEnum.DOUBLE_ACTING + + +fixedpanel = IfcDoorPanelOperationEnum.FIXEDPANEL + + +folding = IfcDoorPanelOperationEnum.FOLDING + + +revolving = IfcDoorPanelOperationEnum.REVOLVING + + +rollingup = IfcDoorPanelOperationEnum.ROLLINGUP + + +sliding = IfcDoorPanelOperationEnum.SLIDING + + +swinging = IfcDoorPanelOperationEnum.SWINGING + + +userdefined = IfcDoorPanelOperationEnum.USERDEFINED + + +notdefined = IfcDoorPanelOperationEnum.NOTDEFINED + + +IfcDoorPanelPositionEnum = enum_namespace() + + +left = IfcDoorPanelPositionEnum.LEFT + + +middle = IfcDoorPanelPositionEnum.MIDDLE + + +right = IfcDoorPanelPositionEnum.RIGHT + + +notdefined = IfcDoorPanelPositionEnum.NOTDEFINED + + +IfcDoorTypeEnum = enum_namespace() + + +boom_barrier = IfcDoorTypeEnum.BOOM_BARRIER + + +door = IfcDoorTypeEnum.DOOR + + +gate = IfcDoorTypeEnum.GATE + + +trapdoor = IfcDoorTypeEnum.TRAPDOOR + + +turnstile = IfcDoorTypeEnum.TURNSTILE + + +userdefined = IfcDoorTypeEnum.USERDEFINED + + +notdefined = IfcDoorTypeEnum.NOTDEFINED + + +IfcDoorTypeOperationEnum = enum_namespace() + + +double_door_double_swing = IfcDoorTypeOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +double_door_folding = IfcDoorTypeOperationEnum.DOUBLE_DOOR_FOLDING + + +double_door_lifting_vertical = IfcDoorTypeOperationEnum.DOUBLE_DOOR_LIFTING_VERTICAL + + +double_door_single_swing = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_door_sliding = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SLIDING + + +double_swing_left = IfcDoorTypeOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorTypeOperationEnum.DOUBLE_SWING_RIGHT + + +folding_to_left = IfcDoorTypeOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorTypeOperationEnum.FOLDING_TO_RIGHT + + +lifting_horizontal = IfcDoorTypeOperationEnum.LIFTING_HORIZONTAL + + +lifting_vertical_left = IfcDoorTypeOperationEnum.LIFTING_VERTICAL_LEFT + + +lifting_vertical_right = IfcDoorTypeOperationEnum.LIFTING_VERTICAL_RIGHT + + +revolving = IfcDoorTypeOperationEnum.REVOLVING + + +revolving_vertical = IfcDoorTypeOperationEnum.REVOLVING_VERTICAL + + +rollingup = IfcDoorTypeOperationEnum.ROLLINGUP + + +single_swing_left = IfcDoorTypeOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorTypeOperationEnum.SINGLE_SWING_RIGHT + + +sliding_to_left = IfcDoorTypeOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorTypeOperationEnum.SLIDING_TO_RIGHT + + +swing_fixed_left = IfcDoorTypeOperationEnum.SWING_FIXED_LEFT + + +swing_fixed_right = IfcDoorTypeOperationEnum.SWING_FIXED_RIGHT + + +userdefined = IfcDoorTypeOperationEnum.USERDEFINED + + +notdefined = IfcDoorTypeOperationEnum.NOTDEFINED + + +IfcDuctFittingTypeEnum = enum_namespace() + + +bend = IfcDuctFittingTypeEnum.BEND + + +connector = IfcDuctFittingTypeEnum.CONNECTOR + + +entry = IfcDuctFittingTypeEnum.ENTRY + + +exit = IfcDuctFittingTypeEnum.EXIT + + +junction = IfcDuctFittingTypeEnum.JUNCTION + + +obstruction = IfcDuctFittingTypeEnum.OBSTRUCTION + + +transition = IfcDuctFittingTypeEnum.TRANSITION + + +userdefined = IfcDuctFittingTypeEnum.USERDEFINED + + +notdefined = IfcDuctFittingTypeEnum.NOTDEFINED + + +IfcDuctSegmentTypeEnum = enum_namespace() + + +flexiblesegment = IfcDuctSegmentTypeEnum.FLEXIBLESEGMENT + + +rigidsegment = IfcDuctSegmentTypeEnum.RIGIDSEGMENT + + +userdefined = IfcDuctSegmentTypeEnum.USERDEFINED + + +notdefined = IfcDuctSegmentTypeEnum.NOTDEFINED + + +IfcDuctSilencerTypeEnum = enum_namespace() + + +flatoval = IfcDuctSilencerTypeEnum.FLATOVAL + + +rectangular = IfcDuctSilencerTypeEnum.RECTANGULAR + + +round = IfcDuctSilencerTypeEnum.ROUND + + +userdefined = IfcDuctSilencerTypeEnum.USERDEFINED + + +notdefined = IfcDuctSilencerTypeEnum.NOTDEFINED + + +IfcEarthworksCutTypeEnum = enum_namespace() + + +base_excavation = IfcEarthworksCutTypeEnum.BASE_EXCAVATION + + +cut = IfcEarthworksCutTypeEnum.CUT + + +dredging = IfcEarthworksCutTypeEnum.DREDGING + + +excavation = IfcEarthworksCutTypeEnum.EXCAVATION + + +overexcavation = IfcEarthworksCutTypeEnum.OVEREXCAVATION + + +pavementmilling = IfcEarthworksCutTypeEnum.PAVEMENTMILLING + + +stepexcavation = IfcEarthworksCutTypeEnum.STEPEXCAVATION + + +topsoilremoval = IfcEarthworksCutTypeEnum.TOPSOILREMOVAL + + +trench = IfcEarthworksCutTypeEnum.TRENCH + + +userdefined = IfcEarthworksCutTypeEnum.USERDEFINED + + +notdefined = IfcEarthworksCutTypeEnum.NOTDEFINED + + +IfcEarthworksFillTypeEnum = enum_namespace() + + +backfill = IfcEarthworksFillTypeEnum.BACKFILL + + +counterweight = IfcEarthworksFillTypeEnum.COUNTERWEIGHT + + +embankment = IfcEarthworksFillTypeEnum.EMBANKMENT + + +slopefill = IfcEarthworksFillTypeEnum.SLOPEFILL + + +subgrade = IfcEarthworksFillTypeEnum.SUBGRADE + + +subgradebed = IfcEarthworksFillTypeEnum.SUBGRADEBED + + +transitionsection = IfcEarthworksFillTypeEnum.TRANSITIONSECTION + + +userdefined = IfcEarthworksFillTypeEnum.USERDEFINED + + +notdefined = IfcEarthworksFillTypeEnum.NOTDEFINED + + +IfcElectricApplianceTypeEnum = enum_namespace() + + +dishwasher = IfcElectricApplianceTypeEnum.DISHWASHER + + +electriccooker = IfcElectricApplianceTypeEnum.ELECTRICCOOKER + + +freestandingelectricheater = IfcElectricApplianceTypeEnum.FREESTANDINGELECTRICHEATER + + +freestandingfan = IfcElectricApplianceTypeEnum.FREESTANDINGFAN + + +freestandingwatercooler = IfcElectricApplianceTypeEnum.FREESTANDINGWATERCOOLER + + +freestandingwaterheater = IfcElectricApplianceTypeEnum.FREESTANDINGWATERHEATER + + +freezer = IfcElectricApplianceTypeEnum.FREEZER + + +fridge_freezer = IfcElectricApplianceTypeEnum.FRIDGE_FREEZER + + +handdryer = IfcElectricApplianceTypeEnum.HANDDRYER + + +kitchenmachine = IfcElectricApplianceTypeEnum.KITCHENMACHINE + + +microwave = IfcElectricApplianceTypeEnum.MICROWAVE + + +photocopier = IfcElectricApplianceTypeEnum.PHOTOCOPIER + + +refrigerator = IfcElectricApplianceTypeEnum.REFRIGERATOR + + +tumbledryer = IfcElectricApplianceTypeEnum.TUMBLEDRYER + + +vendingmachine = IfcElectricApplianceTypeEnum.VENDINGMACHINE + + +washingmachine = IfcElectricApplianceTypeEnum.WASHINGMACHINE + + +userdefined = IfcElectricApplianceTypeEnum.USERDEFINED + + +notdefined = IfcElectricApplianceTypeEnum.NOTDEFINED + + +IfcElectricDistributionBoardTypeEnum = enum_namespace() + + +consumerunit = IfcElectricDistributionBoardTypeEnum.CONSUMERUNIT + + +distributionboard = IfcElectricDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +motorcontrolcentre = IfcElectricDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +switchboard = IfcElectricDistributionBoardTypeEnum.SWITCHBOARD + + +userdefined = IfcElectricDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcElectricDistributionBoardTypeEnum.NOTDEFINED + + +IfcElectricFlowStorageDeviceTypeEnum = enum_namespace() + + +battery = IfcElectricFlowStorageDeviceTypeEnum.BATTERY + + +capacitor = IfcElectricFlowStorageDeviceTypeEnum.CAPACITOR + + +capacitorbank = IfcElectricFlowStorageDeviceTypeEnum.CAPACITORBANK + + +compensator = IfcElectricFlowStorageDeviceTypeEnum.COMPENSATOR + + +harmonicfilter = IfcElectricFlowStorageDeviceTypeEnum.HARMONICFILTER + + +inductor = IfcElectricFlowStorageDeviceTypeEnum.INDUCTOR + + +inductorbank = IfcElectricFlowStorageDeviceTypeEnum.INDUCTORBANK + + +recharger = IfcElectricFlowStorageDeviceTypeEnum.RECHARGER + + +ups = IfcElectricFlowStorageDeviceTypeEnum.UPS + + +userdefined = IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowStorageDeviceTypeEnum.NOTDEFINED + + +IfcElectricFlowTreatmentDeviceTypeEnum = enum_namespace() + + +electronicfilter = IfcElectricFlowTreatmentDeviceTypeEnum.ELECTRONICFILTER + + +userdefined = IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowTreatmentDeviceTypeEnum.NOTDEFINED + + +IfcElectricGeneratorTypeEnum = enum_namespace() + + +chp = IfcElectricGeneratorTypeEnum.CHP + + +enginegenerator = IfcElectricGeneratorTypeEnum.ENGINEGENERATOR + + +standalone = IfcElectricGeneratorTypeEnum.STANDALONE + + +userdefined = IfcElectricGeneratorTypeEnum.USERDEFINED + + +notdefined = IfcElectricGeneratorTypeEnum.NOTDEFINED + + +IfcElectricMotorTypeEnum = enum_namespace() + + +dc = IfcElectricMotorTypeEnum.DC + + +induction = IfcElectricMotorTypeEnum.INDUCTION + + +polyphase = IfcElectricMotorTypeEnum.POLYPHASE + + +reluctancesynchronous = IfcElectricMotorTypeEnum.RELUCTANCESYNCHRONOUS + + +synchronous = IfcElectricMotorTypeEnum.SYNCHRONOUS + + +userdefined = IfcElectricMotorTypeEnum.USERDEFINED + + +notdefined = IfcElectricMotorTypeEnum.NOTDEFINED + + +IfcElectricTimeControlTypeEnum = enum_namespace() + + +relay = IfcElectricTimeControlTypeEnum.RELAY + + +timeclock = IfcElectricTimeControlTypeEnum.TIMECLOCK + + +timedelay = IfcElectricTimeControlTypeEnum.TIMEDELAY + + +userdefined = IfcElectricTimeControlTypeEnum.USERDEFINED + + +notdefined = IfcElectricTimeControlTypeEnum.NOTDEFINED + + +IfcElementAssemblyTypeEnum = enum_namespace() + + +abutment = IfcElementAssemblyTypeEnum.ABUTMENT + + +accessory_assembly = IfcElementAssemblyTypeEnum.ACCESSORY_ASSEMBLY + + +arch = IfcElementAssemblyTypeEnum.ARCH + + +beam_grid = IfcElementAssemblyTypeEnum.BEAM_GRID + + +braced_frame = IfcElementAssemblyTypeEnum.BRACED_FRAME + + +cross_bracing = IfcElementAssemblyTypeEnum.CROSS_BRACING + + +deck = IfcElementAssemblyTypeEnum.DECK + + +dilatationpanel = IfcElementAssemblyTypeEnum.DILATATIONPANEL + + +entranceworks = IfcElementAssemblyTypeEnum.ENTRANCEWORKS + + +girder = IfcElementAssemblyTypeEnum.GIRDER + + +grid = IfcElementAssemblyTypeEnum.GRID + + +mast = IfcElementAssemblyTypeEnum.MAST + + +pier = IfcElementAssemblyTypeEnum.PIER + + +pylon = IfcElementAssemblyTypeEnum.PYLON + + +rail_mechanical_equipment_assembly = IfcElementAssemblyTypeEnum.RAIL_MECHANICAL_EQUIPMENT_ASSEMBLY + + +reinforcement_unit = IfcElementAssemblyTypeEnum.REINFORCEMENT_UNIT + + +rigid_frame = IfcElementAssemblyTypeEnum.RIGID_FRAME + + +shelter = IfcElementAssemblyTypeEnum.SHELTER + + +signalassembly = IfcElementAssemblyTypeEnum.SIGNALASSEMBLY + + +slab_field = IfcElementAssemblyTypeEnum.SLAB_FIELD + + +sumpbuster = IfcElementAssemblyTypeEnum.SUMPBUSTER + + +supportingassembly = IfcElementAssemblyTypeEnum.SUPPORTINGASSEMBLY + + +suspensionassembly = IfcElementAssemblyTypeEnum.SUSPENSIONASSEMBLY + + +trackpanel = IfcElementAssemblyTypeEnum.TRACKPANEL + + +traction_switching_assembly = IfcElementAssemblyTypeEnum.TRACTION_SWITCHING_ASSEMBLY + + +traffic_calming_device = IfcElementAssemblyTypeEnum.TRAFFIC_CALMING_DEVICE + + +truss = IfcElementAssemblyTypeEnum.TRUSS + + +turnoutpanel = IfcElementAssemblyTypeEnum.TURNOUTPANEL + + +userdefined = IfcElementAssemblyTypeEnum.USERDEFINED + + +notdefined = IfcElementAssemblyTypeEnum.NOTDEFINED + + +IfcElementCompositionEnum = enum_namespace() + + +complex = IfcElementCompositionEnum.COMPLEX + + +element = IfcElementCompositionEnum.ELEMENT + + +partial = IfcElementCompositionEnum.PARTIAL + + +IfcEngineTypeEnum = enum_namespace() + + +externalcombustion = IfcEngineTypeEnum.EXTERNALCOMBUSTION + + +internalcombustion = IfcEngineTypeEnum.INTERNALCOMBUSTION + + +userdefined = IfcEngineTypeEnum.USERDEFINED + + +notdefined = IfcEngineTypeEnum.NOTDEFINED + + +IfcEvaporativeCoolerTypeEnum = enum_namespace() + + +directevaporativeairwasher = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEAIRWASHER + + +directevaporativepackagedrotaryaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER + + +directevaporativerandommediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER + + +directevaporativerigidmediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER + + +directevaporativeslingerspackagedaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER + + +indirectdirectcombination = IfcEvaporativeCoolerTypeEnum.INDIRECTDIRECTCOMBINATION + + +indirectevaporativecoolingtowerorcoilcooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER + + +indirectevaporativepackageaircooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEPACKAGEAIRCOOLER + + +indirectevaporativewetcoil = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEWETCOIL + + +userdefined = IfcEvaporativeCoolerTypeEnum.USERDEFINED + + +notdefined = IfcEvaporativeCoolerTypeEnum.NOTDEFINED + + +IfcEvaporatorTypeEnum = enum_namespace() + + +directexpansion = IfcEvaporatorTypeEnum.DIRECTEXPANSION + + +directexpansionbrazedplate = IfcEvaporatorTypeEnum.DIRECTEXPANSIONBRAZEDPLATE + + +directexpansionshellandtube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONSHELLANDTUBE + + +directexpansiontubeintube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONTUBEINTUBE + + +floodedshellandtube = IfcEvaporatorTypeEnum.FLOODEDSHELLANDTUBE + + +shellandcoil = IfcEvaporatorTypeEnum.SHELLANDCOIL + + +userdefined = IfcEvaporatorTypeEnum.USERDEFINED + + +notdefined = IfcEvaporatorTypeEnum.NOTDEFINED + + +IfcEventTriggerTypeEnum = enum_namespace() + + +eventcomplex = IfcEventTriggerTypeEnum.EVENTCOMPLEX + + +eventmessage = IfcEventTriggerTypeEnum.EVENTMESSAGE + + +eventrule = IfcEventTriggerTypeEnum.EVENTRULE + + +eventtime = IfcEventTriggerTypeEnum.EVENTTIME + + +userdefined = IfcEventTriggerTypeEnum.USERDEFINED + + +notdefined = IfcEventTriggerTypeEnum.NOTDEFINED + + +IfcEventTypeEnum = enum_namespace() + + +endevent = IfcEventTypeEnum.ENDEVENT + + +intermediateevent = IfcEventTypeEnum.INTERMEDIATEEVENT + + +startevent = IfcEventTypeEnum.STARTEVENT + + +userdefined = IfcEventTypeEnum.USERDEFINED + + +notdefined = IfcEventTypeEnum.NOTDEFINED + + +IfcExternalSpatialElementTypeEnum = enum_namespace() + + +external = IfcExternalSpatialElementTypeEnum.EXTERNAL + + +external_earth = IfcExternalSpatialElementTypeEnum.EXTERNAL_EARTH + + +external_fire = IfcExternalSpatialElementTypeEnum.EXTERNAL_FIRE + + +external_water = IfcExternalSpatialElementTypeEnum.EXTERNAL_WATER + + +userdefined = IfcExternalSpatialElementTypeEnum.USERDEFINED + + +notdefined = IfcExternalSpatialElementTypeEnum.NOTDEFINED + + +IfcFacilityPartCommonTypeEnum = enum_namespace() + + +aboveground = IfcFacilityPartCommonTypeEnum.ABOVEGROUND + + +belowground = IfcFacilityPartCommonTypeEnum.BELOWGROUND + + +junction = IfcFacilityPartCommonTypeEnum.JUNCTION + + +levelcrossing = IfcFacilityPartCommonTypeEnum.LEVELCROSSING + + +segment = IfcFacilityPartCommonTypeEnum.SEGMENT + + +substructure = IfcFacilityPartCommonTypeEnum.SUBSTRUCTURE + + +superstructure = IfcFacilityPartCommonTypeEnum.SUPERSTRUCTURE + + +terminal = IfcFacilityPartCommonTypeEnum.TERMINAL + + +userdefined = IfcFacilityPartCommonTypeEnum.USERDEFINED + + +notdefined = IfcFacilityPartCommonTypeEnum.NOTDEFINED + + +IfcFacilityUsageEnum = enum_namespace() + + +lateral = IfcFacilityUsageEnum.LATERAL + + +longitudinal = IfcFacilityUsageEnum.LONGITUDINAL + + +region = IfcFacilityUsageEnum.REGION + + +vertical = IfcFacilityUsageEnum.VERTICAL + + +userdefined = IfcFacilityUsageEnum.USERDEFINED + + +notdefined = IfcFacilityUsageEnum.NOTDEFINED + + +IfcFanTypeEnum = enum_namespace() + + +centrifugalairfoil = IfcFanTypeEnum.CENTRIFUGALAIRFOIL + + +centrifugalbackwardinclinedcurved = IfcFanTypeEnum.CENTRIFUGALBACKWARDINCLINEDCURVED + + +centrifugalforwardcurved = IfcFanTypeEnum.CENTRIFUGALFORWARDCURVED + + +centrifugalradial = IfcFanTypeEnum.CENTRIFUGALRADIAL + + +propelloraxial = IfcFanTypeEnum.PROPELLORAXIAL + + +tubeaxial = IfcFanTypeEnum.TUBEAXIAL + + +vaneaxial = IfcFanTypeEnum.VANEAXIAL + + +userdefined = IfcFanTypeEnum.USERDEFINED + + +notdefined = IfcFanTypeEnum.NOTDEFINED + + +IfcFastenerTypeEnum = enum_namespace() + + +glue = IfcFastenerTypeEnum.GLUE + + +mortar = IfcFastenerTypeEnum.MORTAR + + +weld = IfcFastenerTypeEnum.WELD + + +userdefined = IfcFastenerTypeEnum.USERDEFINED + + +notdefined = IfcFastenerTypeEnum.NOTDEFINED + + +IfcFilterTypeEnum = enum_namespace() + + +airparticlefilter = IfcFilterTypeEnum.AIRPARTICLEFILTER + + +compressedairfilter = IfcFilterTypeEnum.COMPRESSEDAIRFILTER + + +odorfilter = IfcFilterTypeEnum.ODORFILTER + + +oilfilter = IfcFilterTypeEnum.OILFILTER + + +strainer = IfcFilterTypeEnum.STRAINER + + +waterfilter = IfcFilterTypeEnum.WATERFILTER + + +userdefined = IfcFilterTypeEnum.USERDEFINED + + +notdefined = IfcFilterTypeEnum.NOTDEFINED + + +IfcFireSuppressionTerminalTypeEnum = enum_namespace() + + +breechinginlet = IfcFireSuppressionTerminalTypeEnum.BREECHINGINLET + + +firehydrant = IfcFireSuppressionTerminalTypeEnum.FIREHYDRANT + + +firemonitor = IfcFireSuppressionTerminalTypeEnum.FIREMONITOR + + +hosereel = IfcFireSuppressionTerminalTypeEnum.HOSEREEL + + +sprinkler = IfcFireSuppressionTerminalTypeEnum.SPRINKLER + + +sprinklerdeflector = IfcFireSuppressionTerminalTypeEnum.SPRINKLERDEFLECTOR + + +userdefined = IfcFireSuppressionTerminalTypeEnum.USERDEFINED + + +notdefined = IfcFireSuppressionTerminalTypeEnum.NOTDEFINED + + +IfcFlowDirectionEnum = enum_namespace() + + +sink = IfcFlowDirectionEnum.SINK + + +source = IfcFlowDirectionEnum.SOURCE + + +sourceandsink = IfcFlowDirectionEnum.SOURCEANDSINK + + +notdefined = IfcFlowDirectionEnum.NOTDEFINED + + +IfcFlowInstrumentTypeEnum = enum_namespace() + + +ammeter = IfcFlowInstrumentTypeEnum.AMMETER + + +combined = IfcFlowInstrumentTypeEnum.COMBINED + + +frequencymeter = IfcFlowInstrumentTypeEnum.FREQUENCYMETER + + +phaseanglemeter = IfcFlowInstrumentTypeEnum.PHASEANGLEMETER + + +powerfactormeter = IfcFlowInstrumentTypeEnum.POWERFACTORMETER + + +pressuregauge = IfcFlowInstrumentTypeEnum.PRESSUREGAUGE + + +thermometer = IfcFlowInstrumentTypeEnum.THERMOMETER + + +voltmeter = IfcFlowInstrumentTypeEnum.VOLTMETER + + +voltmeter_peak = IfcFlowInstrumentTypeEnum.VOLTMETER_PEAK + + +voltmeter_rms = IfcFlowInstrumentTypeEnum.VOLTMETER_RMS + + +userdefined = IfcFlowInstrumentTypeEnum.USERDEFINED + + +notdefined = IfcFlowInstrumentTypeEnum.NOTDEFINED + + +IfcFlowMeterTypeEnum = enum_namespace() + + +energymeter = IfcFlowMeterTypeEnum.ENERGYMETER + + +gasmeter = IfcFlowMeterTypeEnum.GASMETER + + +oilmeter = IfcFlowMeterTypeEnum.OILMETER + + +watermeter = IfcFlowMeterTypeEnum.WATERMETER + + +userdefined = IfcFlowMeterTypeEnum.USERDEFINED + + +notdefined = IfcFlowMeterTypeEnum.NOTDEFINED + + +IfcFootingTypeEnum = enum_namespace() + + +caisson_foundation = IfcFootingTypeEnum.CAISSON_FOUNDATION + + +footing_beam = IfcFootingTypeEnum.FOOTING_BEAM + + +pad_footing = IfcFootingTypeEnum.PAD_FOOTING + + +pile_cap = IfcFootingTypeEnum.PILE_CAP + + +strip_footing = IfcFootingTypeEnum.STRIP_FOOTING + + +userdefined = IfcFootingTypeEnum.USERDEFINED + + +notdefined = IfcFootingTypeEnum.NOTDEFINED + + +IfcFurnitureTypeEnum = enum_namespace() + + +bed = IfcFurnitureTypeEnum.BED + + +chair = IfcFurnitureTypeEnum.CHAIR + + +desk = IfcFurnitureTypeEnum.DESK + + +filecabinet = IfcFurnitureTypeEnum.FILECABINET + + +shelf = IfcFurnitureTypeEnum.SHELF + + +sofa = IfcFurnitureTypeEnum.SOFA + + +table = IfcFurnitureTypeEnum.TABLE + + +technicalcabinet = IfcFurnitureTypeEnum.TECHNICALCABINET + + +userdefined = IfcFurnitureTypeEnum.USERDEFINED + + +notdefined = IfcFurnitureTypeEnum.NOTDEFINED + + +IfcGeographicElementTypeEnum = enum_namespace() + + +soil_boring_point = IfcGeographicElementTypeEnum.SOIL_BORING_POINT + + +terrain = IfcGeographicElementTypeEnum.TERRAIN + + +vegetation = IfcGeographicElementTypeEnum.VEGETATION + + +userdefined = IfcGeographicElementTypeEnum.USERDEFINED + + +notdefined = IfcGeographicElementTypeEnum.NOTDEFINED + + +IfcGeometricProjectionEnum = enum_namespace() + + +elevation_view = IfcGeometricProjectionEnum.ELEVATION_VIEW + + +graph_view = IfcGeometricProjectionEnum.GRAPH_VIEW + + +model_view = IfcGeometricProjectionEnum.MODEL_VIEW + + +plan_view = IfcGeometricProjectionEnum.PLAN_VIEW + + +reflected_plan_view = IfcGeometricProjectionEnum.REFLECTED_PLAN_VIEW + + +section_view = IfcGeometricProjectionEnum.SECTION_VIEW + + +sketch_view = IfcGeometricProjectionEnum.SKETCH_VIEW + + +userdefined = IfcGeometricProjectionEnum.USERDEFINED + + +notdefined = IfcGeometricProjectionEnum.NOTDEFINED + + +IfcGeotechnicalStratumTypeEnum = enum_namespace() + + +solid = IfcGeotechnicalStratumTypeEnum.SOLID + + +void = IfcGeotechnicalStratumTypeEnum.VOID + + +water = IfcGeotechnicalStratumTypeEnum.WATER + + +userdefined = IfcGeotechnicalStratumTypeEnum.USERDEFINED + + +notdefined = IfcGeotechnicalStratumTypeEnum.NOTDEFINED + + +IfcGlobalOrLocalEnum = enum_namespace() + + +global_coords = IfcGlobalOrLocalEnum.GLOBAL_COORDS + + +local_coords = IfcGlobalOrLocalEnum.LOCAL_COORDS + + +IfcGridTypeEnum = enum_namespace() + + +irregular = IfcGridTypeEnum.IRREGULAR + + +radial = IfcGridTypeEnum.RADIAL + + +rectangular = IfcGridTypeEnum.RECTANGULAR + + +triangular = IfcGridTypeEnum.TRIANGULAR + + +userdefined = IfcGridTypeEnum.USERDEFINED + + +notdefined = IfcGridTypeEnum.NOTDEFINED + + +IfcHeatExchangerTypeEnum = enum_namespace() + + +plate = IfcHeatExchangerTypeEnum.PLATE + + +shellandtube = IfcHeatExchangerTypeEnum.SHELLANDTUBE + + +turnoutheating = IfcHeatExchangerTypeEnum.TURNOUTHEATING + + +userdefined = IfcHeatExchangerTypeEnum.USERDEFINED + + +notdefined = IfcHeatExchangerTypeEnum.NOTDEFINED + + +IfcHumidifierTypeEnum = enum_namespace() + + +adiabaticairwasher = IfcHumidifierTypeEnum.ADIABATICAIRWASHER + + +adiabaticatomizing = IfcHumidifierTypeEnum.ADIABATICATOMIZING + + +adiabaticcompressedairnozzle = IfcHumidifierTypeEnum.ADIABATICCOMPRESSEDAIRNOZZLE + + +adiabaticpan = IfcHumidifierTypeEnum.ADIABATICPAN + + +adiabaticrigidmedia = IfcHumidifierTypeEnum.ADIABATICRIGIDMEDIA + + +adiabaticultrasonic = IfcHumidifierTypeEnum.ADIABATICULTRASONIC + + +adiabaticwettedelement = IfcHumidifierTypeEnum.ADIABATICWETTEDELEMENT + + +assistedbutane = IfcHumidifierTypeEnum.ASSISTEDBUTANE + + +assistedelectric = IfcHumidifierTypeEnum.ASSISTEDELECTRIC + + +assistednaturalgas = IfcHumidifierTypeEnum.ASSISTEDNATURALGAS + + +assistedpropane = IfcHumidifierTypeEnum.ASSISTEDPROPANE + + +assistedsteam = IfcHumidifierTypeEnum.ASSISTEDSTEAM + + +steaminjection = IfcHumidifierTypeEnum.STEAMINJECTION + + +userdefined = IfcHumidifierTypeEnum.USERDEFINED + + +notdefined = IfcHumidifierTypeEnum.NOTDEFINED + + +IfcImpactProtectionDeviceTypeEnum = enum_namespace() + + +bumper = IfcImpactProtectionDeviceTypeEnum.BUMPER + + +crashcushion = IfcImpactProtectionDeviceTypeEnum.CRASHCUSHION + + +dampingsystem = IfcImpactProtectionDeviceTypeEnum.DAMPINGSYSTEM + + +fender = IfcImpactProtectionDeviceTypeEnum.FENDER + + +userdefined = IfcImpactProtectionDeviceTypeEnum.USERDEFINED + + +notdefined = IfcImpactProtectionDeviceTypeEnum.NOTDEFINED + + +IfcInterceptorTypeEnum = enum_namespace() + + +cyclonic = IfcInterceptorTypeEnum.CYCLONIC + + +grease = IfcInterceptorTypeEnum.GREASE + + +oil = IfcInterceptorTypeEnum.OIL + + +petrol = IfcInterceptorTypeEnum.PETROL + + +userdefined = IfcInterceptorTypeEnum.USERDEFINED + + +notdefined = IfcInterceptorTypeEnum.NOTDEFINED + + +IfcInternalOrExternalEnum = enum_namespace() + + +external = IfcInternalOrExternalEnum.EXTERNAL + + +external_earth = IfcInternalOrExternalEnum.EXTERNAL_EARTH + + +external_fire = IfcInternalOrExternalEnum.EXTERNAL_FIRE + + +external_water = IfcInternalOrExternalEnum.EXTERNAL_WATER + + +internal = IfcInternalOrExternalEnum.INTERNAL + + +notdefined = IfcInternalOrExternalEnum.NOTDEFINED + + +IfcInventoryTypeEnum = enum_namespace() + + +assetinventory = IfcInventoryTypeEnum.ASSETINVENTORY + + +furnitureinventory = IfcInventoryTypeEnum.FURNITUREINVENTORY + + +spaceinventory = IfcInventoryTypeEnum.SPACEINVENTORY + + +userdefined = IfcInventoryTypeEnum.USERDEFINED + + +notdefined = IfcInventoryTypeEnum.NOTDEFINED + + +IfcJunctionBoxTypeEnum = enum_namespace() + + +data = IfcJunctionBoxTypeEnum.DATA + + +power = IfcJunctionBoxTypeEnum.POWER + + +userdefined = IfcJunctionBoxTypeEnum.USERDEFINED + + +notdefined = IfcJunctionBoxTypeEnum.NOTDEFINED + + +IfcKerbTypeEnum = enum_namespace() + + +userdefined = IfcKerbTypeEnum.USERDEFINED + + +notdefined = IfcKerbTypeEnum.NOTDEFINED + + +IfcKnotType = enum_namespace() + + +piecewise_bezier_knots = IfcKnotType.PIECEWISE_BEZIER_KNOTS + + +quasi_uniform_knots = IfcKnotType.QUASI_UNIFORM_KNOTS + + +uniform_knots = IfcKnotType.UNIFORM_KNOTS + + +unspecified = IfcKnotType.UNSPECIFIED + + +IfcLaborResourceTypeEnum = enum_namespace() + + +administration = IfcLaborResourceTypeEnum.ADMINISTRATION + + +carpentry = IfcLaborResourceTypeEnum.CARPENTRY + + +cleaning = IfcLaborResourceTypeEnum.CLEANING + + +concrete = IfcLaborResourceTypeEnum.CONCRETE + + +drywall = IfcLaborResourceTypeEnum.DRYWALL + + +electric = IfcLaborResourceTypeEnum.ELECTRIC + + +finishing = IfcLaborResourceTypeEnum.FINISHING + + +flooring = IfcLaborResourceTypeEnum.FLOORING + + +general = IfcLaborResourceTypeEnum.GENERAL + + +hvac = IfcLaborResourceTypeEnum.HVAC + + +landscaping = IfcLaborResourceTypeEnum.LANDSCAPING + + +masonry = IfcLaborResourceTypeEnum.MASONRY + + +painting = IfcLaborResourceTypeEnum.PAINTING + + +paving = IfcLaborResourceTypeEnum.PAVING + + +plumbing = IfcLaborResourceTypeEnum.PLUMBING + + +roofing = IfcLaborResourceTypeEnum.ROOFING + + +sitegrading = IfcLaborResourceTypeEnum.SITEGRADING + + +steelwork = IfcLaborResourceTypeEnum.STEELWORK + + +surveying = IfcLaborResourceTypeEnum.SURVEYING + + +userdefined = IfcLaborResourceTypeEnum.USERDEFINED + + +notdefined = IfcLaborResourceTypeEnum.NOTDEFINED + + +IfcLampTypeEnum = enum_namespace() + + +compactfluorescent = IfcLampTypeEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLampTypeEnum.FLUORESCENT + + +halogen = IfcLampTypeEnum.HALOGEN + + +highpressuremercury = IfcLampTypeEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLampTypeEnum.HIGHPRESSURESODIUM + + +led = IfcLampTypeEnum.LED + + +metalhalide = IfcLampTypeEnum.METALHALIDE + + +oled = IfcLampTypeEnum.OLED + + +tungstenfilament = IfcLampTypeEnum.TUNGSTENFILAMENT + + +userdefined = IfcLampTypeEnum.USERDEFINED + + +notdefined = IfcLampTypeEnum.NOTDEFINED + + +IfcLayerSetDirectionEnum = enum_namespace() + + +axis1 = IfcLayerSetDirectionEnum.AXIS1 + + +axis2 = IfcLayerSetDirectionEnum.AXIS2 + + +axis3 = IfcLayerSetDirectionEnum.AXIS3 + + +IfcLightDistributionCurveEnum = enum_namespace() + + +type_a = IfcLightDistributionCurveEnum.TYPE_A + + +type_b = IfcLightDistributionCurveEnum.TYPE_B + + +type_c = IfcLightDistributionCurveEnum.TYPE_C + + +notdefined = IfcLightDistributionCurveEnum.NOTDEFINED + + +IfcLightEmissionSourceEnum = enum_namespace() + + +compactfluorescent = IfcLightEmissionSourceEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLightEmissionSourceEnum.FLUORESCENT + + +highpressuremercury = IfcLightEmissionSourceEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLightEmissionSourceEnum.HIGHPRESSURESODIUM + + +lightemittingdiode = IfcLightEmissionSourceEnum.LIGHTEMITTINGDIODE + + +lowpressuresodium = IfcLightEmissionSourceEnum.LOWPRESSURESODIUM + + +lowvoltagehalogen = IfcLightEmissionSourceEnum.LOWVOLTAGEHALOGEN + + +mainvoltagehalogen = IfcLightEmissionSourceEnum.MAINVOLTAGEHALOGEN + + +metalhalide = IfcLightEmissionSourceEnum.METALHALIDE + + +tungstenfilament = IfcLightEmissionSourceEnum.TUNGSTENFILAMENT + + +notdefined = IfcLightEmissionSourceEnum.NOTDEFINED + + +IfcLightFixtureTypeEnum = enum_namespace() + + +directionsource = IfcLightFixtureTypeEnum.DIRECTIONSOURCE + + +pointsource = IfcLightFixtureTypeEnum.POINTSOURCE + + +securitylighting = IfcLightFixtureTypeEnum.SECURITYLIGHTING + + +userdefined = IfcLightFixtureTypeEnum.USERDEFINED + + +notdefined = IfcLightFixtureTypeEnum.NOTDEFINED + + +IfcLiquidTerminalTypeEnum = enum_namespace() + + +hosereel = IfcLiquidTerminalTypeEnum.HOSEREEL + + +loadingarm = IfcLiquidTerminalTypeEnum.LOADINGARM + + +userdefined = IfcLiquidTerminalTypeEnum.USERDEFINED + + +notdefined = IfcLiquidTerminalTypeEnum.NOTDEFINED + + +IfcLoadGroupTypeEnum = enum_namespace() + + +load_case = IfcLoadGroupTypeEnum.LOAD_CASE + + +load_combination = IfcLoadGroupTypeEnum.LOAD_COMBINATION + + +load_group = IfcLoadGroupTypeEnum.LOAD_GROUP + + +userdefined = IfcLoadGroupTypeEnum.USERDEFINED + + +notdefined = IfcLoadGroupTypeEnum.NOTDEFINED + + +IfcLogicalOperatorEnum = enum_namespace() + + +logicaland = IfcLogicalOperatorEnum.LOGICALAND + + +logicalnotand = IfcLogicalOperatorEnum.LOGICALNOTAND + + +logicalnotor = IfcLogicalOperatorEnum.LOGICALNOTOR + + +logicalor = IfcLogicalOperatorEnum.LOGICALOR + + +logicalxor = IfcLogicalOperatorEnum.LOGICALXOR + + +IfcMarineFacilityTypeEnum = enum_namespace() + + +barrierbeach = IfcMarineFacilityTypeEnum.BARRIERBEACH + + +breakwater = IfcMarineFacilityTypeEnum.BREAKWATER + + +canal = IfcMarineFacilityTypeEnum.CANAL + + +drydock = IfcMarineFacilityTypeEnum.DRYDOCK + + +floatingdock = IfcMarineFacilityTypeEnum.FLOATINGDOCK + + +hydrolift = IfcMarineFacilityTypeEnum.HYDROLIFT + + +jetty = IfcMarineFacilityTypeEnum.JETTY + + +launchrecovery = IfcMarineFacilityTypeEnum.LAUNCHRECOVERY + + +marinedefence = IfcMarineFacilityTypeEnum.MARINEDEFENCE + + +navigationalchannel = IfcMarineFacilityTypeEnum.NAVIGATIONALCHANNEL + + +port = IfcMarineFacilityTypeEnum.PORT + + +quay = IfcMarineFacilityTypeEnum.QUAY + + +revetment = IfcMarineFacilityTypeEnum.REVETMENT + + +shiplift = IfcMarineFacilityTypeEnum.SHIPLIFT + + +shiplock = IfcMarineFacilityTypeEnum.SHIPLOCK + + +shipyard = IfcMarineFacilityTypeEnum.SHIPYARD + + +slipway = IfcMarineFacilityTypeEnum.SLIPWAY + + +waterway = IfcMarineFacilityTypeEnum.WATERWAY + + +waterwayshiplift = IfcMarineFacilityTypeEnum.WATERWAYSHIPLIFT + + +userdefined = IfcMarineFacilityTypeEnum.USERDEFINED + + +notdefined = IfcMarineFacilityTypeEnum.NOTDEFINED + + +IfcMarinePartTypeEnum = enum_namespace() + + +abovewaterline = IfcMarinePartTypeEnum.ABOVEWATERLINE + + +anchorage = IfcMarinePartTypeEnum.ANCHORAGE + + +approachchannel = IfcMarinePartTypeEnum.APPROACHCHANNEL + + +belowwaterline = IfcMarinePartTypeEnum.BELOWWATERLINE + + +berthingstructure = IfcMarinePartTypeEnum.BERTHINGSTRUCTURE + + +chamber = IfcMarinePartTypeEnum.CHAMBER + + +cill_level = IfcMarinePartTypeEnum.CILL_LEVEL + + +copelevel = IfcMarinePartTypeEnum.COPELEVEL + + +core = IfcMarinePartTypeEnum.CORE + + +crest = IfcMarinePartTypeEnum.CREST + + +gatehead = IfcMarinePartTypeEnum.GATEHEAD + + +gudingstructure = IfcMarinePartTypeEnum.GUDINGSTRUCTURE + + +highwaterline = IfcMarinePartTypeEnum.HIGHWATERLINE + + +landfield = IfcMarinePartTypeEnum.LANDFIELD + + +leewardside = IfcMarinePartTypeEnum.LEEWARDSIDE + + +lowwaterline = IfcMarinePartTypeEnum.LOWWATERLINE + + +manufacturing = IfcMarinePartTypeEnum.MANUFACTURING + + +navigationalarea = IfcMarinePartTypeEnum.NAVIGATIONALAREA + + +protection = IfcMarinePartTypeEnum.PROTECTION + + +shiptransfer = IfcMarinePartTypeEnum.SHIPTRANSFER + + +storagearea = IfcMarinePartTypeEnum.STORAGEAREA + + +vehicleservicing = IfcMarinePartTypeEnum.VEHICLESERVICING + + +waterfield = IfcMarinePartTypeEnum.WATERFIELD + + +weatherside = IfcMarinePartTypeEnum.WEATHERSIDE + + +userdefined = IfcMarinePartTypeEnum.USERDEFINED + + +notdefined = IfcMarinePartTypeEnum.NOTDEFINED + + +IfcMechanicalFastenerTypeEnum = enum_namespace() + + +anchorbolt = IfcMechanicalFastenerTypeEnum.ANCHORBOLT + + +bolt = IfcMechanicalFastenerTypeEnum.BOLT + + +chain = IfcMechanicalFastenerTypeEnum.CHAIN + + +coupler = IfcMechanicalFastenerTypeEnum.COUPLER + + +dowel = IfcMechanicalFastenerTypeEnum.DOWEL + + +nail = IfcMechanicalFastenerTypeEnum.NAIL + + +nailplate = IfcMechanicalFastenerTypeEnum.NAILPLATE + + +railfastening = IfcMechanicalFastenerTypeEnum.RAILFASTENING + + +railjoint = IfcMechanicalFastenerTypeEnum.RAILJOINT + + +rivet = IfcMechanicalFastenerTypeEnum.RIVET + + +rope = IfcMechanicalFastenerTypeEnum.ROPE + + +screw = IfcMechanicalFastenerTypeEnum.SCREW + + +shearconnector = IfcMechanicalFastenerTypeEnum.SHEARCONNECTOR + + +staple = IfcMechanicalFastenerTypeEnum.STAPLE + + +studshearconnector = IfcMechanicalFastenerTypeEnum.STUDSHEARCONNECTOR + + +userdefined = IfcMechanicalFastenerTypeEnum.USERDEFINED + + +notdefined = IfcMechanicalFastenerTypeEnum.NOTDEFINED + + +IfcMedicalDeviceTypeEnum = enum_namespace() + + +airstation = IfcMedicalDeviceTypeEnum.AIRSTATION + + +feedairunit = IfcMedicalDeviceTypeEnum.FEEDAIRUNIT + + +oxygengenerator = IfcMedicalDeviceTypeEnum.OXYGENGENERATOR + + +oxygenplant = IfcMedicalDeviceTypeEnum.OXYGENPLANT + + +vacuumstation = IfcMedicalDeviceTypeEnum.VACUUMSTATION + + +userdefined = IfcMedicalDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMedicalDeviceTypeEnum.NOTDEFINED + + +IfcMemberTypeEnum = enum_namespace() + + +arch_segment = IfcMemberTypeEnum.ARCH_SEGMENT + + +brace = IfcMemberTypeEnum.BRACE + + +chord = IfcMemberTypeEnum.CHORD + + +collar = IfcMemberTypeEnum.COLLAR + + +member = IfcMemberTypeEnum.MEMBER + + +mullion = IfcMemberTypeEnum.MULLION + + +plate = IfcMemberTypeEnum.PLATE + + +post = IfcMemberTypeEnum.POST + + +purlin = IfcMemberTypeEnum.PURLIN + + +rafter = IfcMemberTypeEnum.RAFTER + + +stay_cable = IfcMemberTypeEnum.STAY_CABLE + + +stiffening_rib = IfcMemberTypeEnum.STIFFENING_RIB + + +stringer = IfcMemberTypeEnum.STRINGER + + +structuralcable = IfcMemberTypeEnum.STRUCTURALCABLE + + +strut = IfcMemberTypeEnum.STRUT + + +stud = IfcMemberTypeEnum.STUD + + +suspender = IfcMemberTypeEnum.SUSPENDER + + +suspension_cable = IfcMemberTypeEnum.SUSPENSION_CABLE + + +tiebar = IfcMemberTypeEnum.TIEBAR + + +userdefined = IfcMemberTypeEnum.USERDEFINED + + +notdefined = IfcMemberTypeEnum.NOTDEFINED + + +IfcMobileTelecommunicationsApplianceTypeEnum = enum_namespace() + + +accesspoint = IfcMobileTelecommunicationsApplianceTypeEnum.ACCESSPOINT + + +basebandunit = IfcMobileTelecommunicationsApplianceTypeEnum.BASEBANDUNIT + + +basetransceiverstation = IfcMobileTelecommunicationsApplianceTypeEnum.BASETRANSCEIVERSTATION + + +e_utran_node_b = IfcMobileTelecommunicationsApplianceTypeEnum.E_UTRAN_NODE_B + + +gateway_gprs_support_node = IfcMobileTelecommunicationsApplianceTypeEnum.GATEWAY_GPRS_SUPPORT_NODE + + +masterunit = IfcMobileTelecommunicationsApplianceTypeEnum.MASTERUNIT + + +mobileswitchingcenter = IfcMobileTelecommunicationsApplianceTypeEnum.MOBILESWITCHINGCENTER + + +mscserver = IfcMobileTelecommunicationsApplianceTypeEnum.MSCSERVER + + +packetcontrolunit = IfcMobileTelecommunicationsApplianceTypeEnum.PACKETCONTROLUNIT + + +remoteradiounit = IfcMobileTelecommunicationsApplianceTypeEnum.REMOTERADIOUNIT + + +remoteunit = IfcMobileTelecommunicationsApplianceTypeEnum.REMOTEUNIT + + +service_gprs_support_node = IfcMobileTelecommunicationsApplianceTypeEnum.SERVICE_GPRS_SUPPORT_NODE + + +subscriberserver = IfcMobileTelecommunicationsApplianceTypeEnum.SUBSCRIBERSERVER + + +userdefined = IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcMobileTelecommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcMooringDeviceTypeEnum = enum_namespace() + + +bollard = IfcMooringDeviceTypeEnum.BOLLARD + + +linetensioner = IfcMooringDeviceTypeEnum.LINETENSIONER + + +magneticdevice = IfcMooringDeviceTypeEnum.MAGNETICDEVICE + + +mooringhooks = IfcMooringDeviceTypeEnum.MOORINGHOOKS + + +vacuumdevice = IfcMooringDeviceTypeEnum.VACUUMDEVICE + + +userdefined = IfcMooringDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMooringDeviceTypeEnum.NOTDEFINED + + +IfcMotorConnectionTypeEnum = enum_namespace() + + +beltdrive = IfcMotorConnectionTypeEnum.BELTDRIVE + + +coupling = IfcMotorConnectionTypeEnum.COUPLING + + +directdrive = IfcMotorConnectionTypeEnum.DIRECTDRIVE + + +userdefined = IfcMotorConnectionTypeEnum.USERDEFINED + + +notdefined = IfcMotorConnectionTypeEnum.NOTDEFINED + + +IfcNavigationElementTypeEnum = enum_namespace() + + +beacon = IfcNavigationElementTypeEnum.BEACON + + +buoy = IfcNavigationElementTypeEnum.BUOY + + +userdefined = IfcNavigationElementTypeEnum.USERDEFINED + + +notdefined = IfcNavigationElementTypeEnum.NOTDEFINED + + +IfcObjectiveEnum = enum_namespace() + + +codecompliance = IfcObjectiveEnum.CODECOMPLIANCE + + +codewaiver = IfcObjectiveEnum.CODEWAIVER + + +designintent = IfcObjectiveEnum.DESIGNINTENT + + +external = IfcObjectiveEnum.EXTERNAL + + +healthandsafety = IfcObjectiveEnum.HEALTHANDSAFETY + + +mergeconflict = IfcObjectiveEnum.MERGECONFLICT + + +modelview = IfcObjectiveEnum.MODELVIEW + + +parameter = IfcObjectiveEnum.PARAMETER + + +requirement = IfcObjectiveEnum.REQUIREMENT + + +specification = IfcObjectiveEnum.SPECIFICATION + + +triggercondition = IfcObjectiveEnum.TRIGGERCONDITION + + +userdefined = IfcObjectiveEnum.USERDEFINED + + +notdefined = IfcObjectiveEnum.NOTDEFINED + + +IfcOccupantTypeEnum = enum_namespace() + + +assignee = IfcOccupantTypeEnum.ASSIGNEE + + +assignor = IfcOccupantTypeEnum.ASSIGNOR + + +lessee = IfcOccupantTypeEnum.LESSEE + + +lessor = IfcOccupantTypeEnum.LESSOR + + +lettingagent = IfcOccupantTypeEnum.LETTINGAGENT + + +owner = IfcOccupantTypeEnum.OWNER + + +tenant = IfcOccupantTypeEnum.TENANT + + +userdefined = IfcOccupantTypeEnum.USERDEFINED + + +notdefined = IfcOccupantTypeEnum.NOTDEFINED + + +IfcOpeningElementTypeEnum = enum_namespace() + + +opening = IfcOpeningElementTypeEnum.OPENING + + +recess = IfcOpeningElementTypeEnum.RECESS + + +userdefined = IfcOpeningElementTypeEnum.USERDEFINED + + +notdefined = IfcOpeningElementTypeEnum.NOTDEFINED + + +IfcOutletTypeEnum = enum_namespace() + + +audiovisualoutlet = IfcOutletTypeEnum.AUDIOVISUALOUTLET + + +communicationsoutlet = IfcOutletTypeEnum.COMMUNICATIONSOUTLET + + +dataoutlet = IfcOutletTypeEnum.DATAOUTLET + + +poweroutlet = IfcOutletTypeEnum.POWEROUTLET + + +telephoneoutlet = IfcOutletTypeEnum.TELEPHONEOUTLET + + +userdefined = IfcOutletTypeEnum.USERDEFINED + + +notdefined = IfcOutletTypeEnum.NOTDEFINED + + +IfcPavementTypeEnum = enum_namespace() + + +flexible = IfcPavementTypeEnum.FLEXIBLE + + +rigid = IfcPavementTypeEnum.RIGID + + +userdefined = IfcPavementTypeEnum.USERDEFINED + + +notdefined = IfcPavementTypeEnum.NOTDEFINED + + +IfcPerformanceHistoryTypeEnum = enum_namespace() + + +userdefined = IfcPerformanceHistoryTypeEnum.USERDEFINED + + +notdefined = IfcPerformanceHistoryTypeEnum.NOTDEFINED + + +IfcPermeableCoveringOperationEnum = enum_namespace() + + +grill = IfcPermeableCoveringOperationEnum.GRILL + + +louver = IfcPermeableCoveringOperationEnum.LOUVER + + +screen = IfcPermeableCoveringOperationEnum.SCREEN + + +userdefined = IfcPermeableCoveringOperationEnum.USERDEFINED + + +notdefined = IfcPermeableCoveringOperationEnum.NOTDEFINED + + +IfcPermitTypeEnum = enum_namespace() + + +access = IfcPermitTypeEnum.ACCESS + + +building = IfcPermitTypeEnum.BUILDING + + +work = IfcPermitTypeEnum.WORK + + +userdefined = IfcPermitTypeEnum.USERDEFINED + + +notdefined = IfcPermitTypeEnum.NOTDEFINED + + +IfcPhysicalOrVirtualEnum = enum_namespace() + + +physical = IfcPhysicalOrVirtualEnum.PHYSICAL + + +virtual = IfcPhysicalOrVirtualEnum.VIRTUAL + + +notdefined = IfcPhysicalOrVirtualEnum.NOTDEFINED + + +IfcPileConstructionEnum = enum_namespace() + + +cast_in_place = IfcPileConstructionEnum.CAST_IN_PLACE + + +composite = IfcPileConstructionEnum.COMPOSITE + + +precast_concrete = IfcPileConstructionEnum.PRECAST_CONCRETE + + +prefab_steel = IfcPileConstructionEnum.PREFAB_STEEL + + +userdefined = IfcPileConstructionEnum.USERDEFINED + + +notdefined = IfcPileConstructionEnum.NOTDEFINED + + +IfcPileTypeEnum = enum_namespace() + + +bored = IfcPileTypeEnum.BORED + + +cohesion = IfcPileTypeEnum.COHESION + + +driven = IfcPileTypeEnum.DRIVEN + + +friction = IfcPileTypeEnum.FRICTION + + +jetgrouting = IfcPileTypeEnum.JETGROUTING + + +support = IfcPileTypeEnum.SUPPORT + + +userdefined = IfcPileTypeEnum.USERDEFINED + + +notdefined = IfcPileTypeEnum.NOTDEFINED + + +IfcPipeFittingTypeEnum = enum_namespace() + + +bend = IfcPipeFittingTypeEnum.BEND + + +connector = IfcPipeFittingTypeEnum.CONNECTOR + + +entry = IfcPipeFittingTypeEnum.ENTRY + + +exit = IfcPipeFittingTypeEnum.EXIT + + +junction = IfcPipeFittingTypeEnum.JUNCTION + + +obstruction = IfcPipeFittingTypeEnum.OBSTRUCTION + + +transition = IfcPipeFittingTypeEnum.TRANSITION + + +userdefined = IfcPipeFittingTypeEnum.USERDEFINED + + +notdefined = IfcPipeFittingTypeEnum.NOTDEFINED + + +IfcPipeSegmentTypeEnum = enum_namespace() + + +culvert = IfcPipeSegmentTypeEnum.CULVERT + + +flexiblesegment = IfcPipeSegmentTypeEnum.FLEXIBLESEGMENT + + +gutter = IfcPipeSegmentTypeEnum.GUTTER + + +rigidsegment = IfcPipeSegmentTypeEnum.RIGIDSEGMENT + + +spool = IfcPipeSegmentTypeEnum.SPOOL + + +userdefined = IfcPipeSegmentTypeEnum.USERDEFINED + + +notdefined = IfcPipeSegmentTypeEnum.NOTDEFINED + + +IfcPlateTypeEnum = enum_namespace() + + +base_plate = IfcPlateTypeEnum.BASE_PLATE + + +cover_plate = IfcPlateTypeEnum.COVER_PLATE + + +curtain_panel = IfcPlateTypeEnum.CURTAIN_PANEL + + +flange_plate = IfcPlateTypeEnum.FLANGE_PLATE + + +gusset_plate = IfcPlateTypeEnum.GUSSET_PLATE + + +sheet = IfcPlateTypeEnum.SHEET + + +splice_plate = IfcPlateTypeEnum.SPLICE_PLATE + + +stiffener_plate = IfcPlateTypeEnum.STIFFENER_PLATE + + +web_plate = IfcPlateTypeEnum.WEB_PLATE + + +userdefined = IfcPlateTypeEnum.USERDEFINED + + +notdefined = IfcPlateTypeEnum.NOTDEFINED + + +IfcPreferredSurfaceCurveRepresentation = enum_namespace() + + +curve3d = IfcPreferredSurfaceCurveRepresentation.CURVE3D + + +pcurve_s1 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S1 + + +pcurve_s2 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S2 + + +IfcProcedureTypeEnum = enum_namespace() + + +advice_caution = IfcProcedureTypeEnum.ADVICE_CAUTION + + +advice_note = IfcProcedureTypeEnum.ADVICE_NOTE + + +advice_warning = IfcProcedureTypeEnum.ADVICE_WARNING + + +calibration = IfcProcedureTypeEnum.CALIBRATION + + +diagnostic = IfcProcedureTypeEnum.DIAGNOSTIC + + +shutdown = IfcProcedureTypeEnum.SHUTDOWN + + +startup = IfcProcedureTypeEnum.STARTUP + + +userdefined = IfcProcedureTypeEnum.USERDEFINED + + +notdefined = IfcProcedureTypeEnum.NOTDEFINED + + +IfcProfileTypeEnum = enum_namespace() + + +area = IfcProfileTypeEnum.AREA + + +curve = IfcProfileTypeEnum.CURVE + + +IfcProjectOrderTypeEnum = enum_namespace() + + +changeorder = IfcProjectOrderTypeEnum.CHANGEORDER + + +maintenanceworkorder = IfcProjectOrderTypeEnum.MAINTENANCEWORKORDER + + +moveorder = IfcProjectOrderTypeEnum.MOVEORDER + + +purchaseorder = IfcProjectOrderTypeEnum.PURCHASEORDER + + +workorder = IfcProjectOrderTypeEnum.WORKORDER + + +userdefined = IfcProjectOrderTypeEnum.USERDEFINED + + +notdefined = IfcProjectOrderTypeEnum.NOTDEFINED + + +IfcProjectedOrTrueLengthEnum = enum_namespace() + + +projected_length = IfcProjectedOrTrueLengthEnum.PROJECTED_LENGTH + + +true_length = IfcProjectedOrTrueLengthEnum.TRUE_LENGTH + + +IfcProjectionElementTypeEnum = enum_namespace() + + +blister = IfcProjectionElementTypeEnum.BLISTER + + +deviator = IfcProjectionElementTypeEnum.DEVIATOR + + +userdefined = IfcProjectionElementTypeEnum.USERDEFINED + + +notdefined = IfcProjectionElementTypeEnum.NOTDEFINED + + +IfcPropertySetTemplateTypeEnum = enum_namespace() + + +pset_materialdriven = IfcPropertySetTemplateTypeEnum.PSET_MATERIALDRIVEN + + +pset_occurrencedriven = IfcPropertySetTemplateTypeEnum.PSET_OCCURRENCEDRIVEN + + +pset_performancedriven = IfcPropertySetTemplateTypeEnum.PSET_PERFORMANCEDRIVEN + + +pset_profiledriven = IfcPropertySetTemplateTypeEnum.PSET_PROFILEDRIVEN + + +pset_typedrivenonly = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENONLY + + +pset_typedrivenoverride = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENOVERRIDE + + +qto_occurrencedriven = IfcPropertySetTemplateTypeEnum.QTO_OCCURRENCEDRIVEN + + +qto_typedrivenonly = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENONLY + + +qto_typedrivenoverride = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENOVERRIDE + + +notdefined = IfcPropertySetTemplateTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTrippingUnitTypeEnum = enum_namespace() + + +electromagnetic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTROMAGNETIC + + +electronic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTRONIC + + +residualcurrent = IfcProtectiveDeviceTrippingUnitTypeEnum.RESIDUALCURRENT + + +thermal = IfcProtectiveDeviceTrippingUnitTypeEnum.THERMAL + + +userdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTypeEnum = enum_namespace() + + +anti_arcing_device = IfcProtectiveDeviceTypeEnum.ANTI_ARCING_DEVICE + + +circuitbreaker = IfcProtectiveDeviceTypeEnum.CIRCUITBREAKER + + +earthingswitch = IfcProtectiveDeviceTypeEnum.EARTHINGSWITCH + + +earthleakagecircuitbreaker = IfcProtectiveDeviceTypeEnum.EARTHLEAKAGECIRCUITBREAKER + + +fusedisconnector = IfcProtectiveDeviceTypeEnum.FUSEDISCONNECTOR + + +residualcurrentcircuitbreaker = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTCIRCUITBREAKER + + +residualcurrentswitch = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTSWITCH + + +sparkgap = IfcProtectiveDeviceTypeEnum.SPARKGAP + + +varistor = IfcProtectiveDeviceTypeEnum.VARISTOR + + +voltagelimiter = IfcProtectiveDeviceTypeEnum.VOLTAGELIMITER + + +userdefined = IfcProtectiveDeviceTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTypeEnum.NOTDEFINED + + +IfcPumpTypeEnum = enum_namespace() + + +circulator = IfcPumpTypeEnum.CIRCULATOR + + +endsuction = IfcPumpTypeEnum.ENDSUCTION + + +splitcase = IfcPumpTypeEnum.SPLITCASE + + +submersiblepump = IfcPumpTypeEnum.SUBMERSIBLEPUMP + + +sumppump = IfcPumpTypeEnum.SUMPPUMP + + +verticalinline = IfcPumpTypeEnum.VERTICALINLINE + + +verticalturbine = IfcPumpTypeEnum.VERTICALTURBINE + + +userdefined = IfcPumpTypeEnum.USERDEFINED + + +notdefined = IfcPumpTypeEnum.NOTDEFINED + + +IfcRailTypeEnum = enum_namespace() + + +blade = IfcRailTypeEnum.BLADE + + +checkrail = IfcRailTypeEnum.CHECKRAIL + + +guardrail = IfcRailTypeEnum.GUARDRAIL + + +rackrail = IfcRailTypeEnum.RACKRAIL + + +rail = IfcRailTypeEnum.RAIL + + +stockrail = IfcRailTypeEnum.STOCKRAIL + + +userdefined = IfcRailTypeEnum.USERDEFINED + + +notdefined = IfcRailTypeEnum.NOTDEFINED + + +IfcRailingTypeEnum = enum_namespace() + + +balustrade = IfcRailingTypeEnum.BALUSTRADE + + +fence = IfcRailingTypeEnum.FENCE + + +guardrail = IfcRailingTypeEnum.GUARDRAIL + + +handrail = IfcRailingTypeEnum.HANDRAIL + + +userdefined = IfcRailingTypeEnum.USERDEFINED + + +notdefined = IfcRailingTypeEnum.NOTDEFINED + + +IfcRailwayPartTypeEnum = enum_namespace() + + +dilatationsuperstructure = IfcRailwayPartTypeEnum.DILATATIONSUPERSTRUCTURE + + +linesidestructure = IfcRailwayPartTypeEnum.LINESIDESTRUCTURE + + +linesidestructurepart = IfcRailwayPartTypeEnum.LINESIDESTRUCTUREPART + + +plaintracksuperstructure = IfcRailwayPartTypeEnum.PLAINTRACKSUPERSTRUCTURE + + +superstructure = IfcRailwayPartTypeEnum.SUPERSTRUCTURE + + +trackstructure = IfcRailwayPartTypeEnum.TRACKSTRUCTURE + + +trackstructurepart = IfcRailwayPartTypeEnum.TRACKSTRUCTUREPART + + +turnoutsuperstructure = IfcRailwayPartTypeEnum.TURNOUTSUPERSTRUCTURE + + +userdefined = IfcRailwayPartTypeEnum.USERDEFINED + + +notdefined = IfcRailwayPartTypeEnum.NOTDEFINED + + +IfcRailwayTypeEnum = enum_namespace() + + +userdefined = IfcRailwayTypeEnum.USERDEFINED + + +notdefined = IfcRailwayTypeEnum.NOTDEFINED + + +IfcRampFlightTypeEnum = enum_namespace() + + +spiral = IfcRampFlightTypeEnum.SPIRAL + + +straight = IfcRampFlightTypeEnum.STRAIGHT + + +userdefined = IfcRampFlightTypeEnum.USERDEFINED + + +notdefined = IfcRampFlightTypeEnum.NOTDEFINED + + +IfcRampTypeEnum = enum_namespace() + + +half_turn_ramp = IfcRampTypeEnum.HALF_TURN_RAMP + + +quarter_turn_ramp = IfcRampTypeEnum.QUARTER_TURN_RAMP + + +spiral_ramp = IfcRampTypeEnum.SPIRAL_RAMP + + +straight_run_ramp = IfcRampTypeEnum.STRAIGHT_RUN_RAMP + + +two_quarter_turn_ramp = IfcRampTypeEnum.TWO_QUARTER_TURN_RAMP + + +two_straight_run_ramp = IfcRampTypeEnum.TWO_STRAIGHT_RUN_RAMP + + +userdefined = IfcRampTypeEnum.USERDEFINED + + +notdefined = IfcRampTypeEnum.NOTDEFINED + + +IfcRecurrenceTypeEnum = enum_namespace() + + +by_day_count = IfcRecurrenceTypeEnum.BY_DAY_COUNT + + +by_weekday_count = IfcRecurrenceTypeEnum.BY_WEEKDAY_COUNT + + +daily = IfcRecurrenceTypeEnum.DAILY + + +monthly_by_day_of_month = IfcRecurrenceTypeEnum.MONTHLY_BY_DAY_OF_MONTH + + +monthly_by_position = IfcRecurrenceTypeEnum.MONTHLY_BY_POSITION + + +weekly = IfcRecurrenceTypeEnum.WEEKLY + + +yearly_by_day_of_month = IfcRecurrenceTypeEnum.YEARLY_BY_DAY_OF_MONTH + + +yearly_by_position = IfcRecurrenceTypeEnum.YEARLY_BY_POSITION + + +IfcReferentTypeEnum = enum_namespace() + + +boundary = IfcReferentTypeEnum.BOUNDARY + + +intersection = IfcReferentTypeEnum.INTERSECTION + + +kilopoint = IfcReferentTypeEnum.KILOPOINT + + +landmark = IfcReferentTypeEnum.LANDMARK + + +milepoint = IfcReferentTypeEnum.MILEPOINT + + +position = IfcReferentTypeEnum.POSITION + + +referencemarker = IfcReferentTypeEnum.REFERENCEMARKER + + +station = IfcReferentTypeEnum.STATION + + +userdefined = IfcReferentTypeEnum.USERDEFINED + + +notdefined = IfcReferentTypeEnum.NOTDEFINED + + +IfcReflectanceMethodEnum = enum_namespace() + + +blinn = IfcReflectanceMethodEnum.BLINN + + +flat = IfcReflectanceMethodEnum.FLAT + + +glass = IfcReflectanceMethodEnum.GLASS + + +matt = IfcReflectanceMethodEnum.MATT + + +metal = IfcReflectanceMethodEnum.METAL + + +mirror = IfcReflectanceMethodEnum.MIRROR + + +phong = IfcReflectanceMethodEnum.PHONG + + +physical = IfcReflectanceMethodEnum.PHYSICAL + + +plastic = IfcReflectanceMethodEnum.PLASTIC + + +strauss = IfcReflectanceMethodEnum.STRAUSS + + +notdefined = IfcReflectanceMethodEnum.NOTDEFINED + + +IfcReinforcedSoilTypeEnum = enum_namespace() + + +dynamicallycompacted = IfcReinforcedSoilTypeEnum.DYNAMICALLYCOMPACTED + + +grouted = IfcReinforcedSoilTypeEnum.GROUTED + + +replaced = IfcReinforcedSoilTypeEnum.REPLACED + + +rollercompacted = IfcReinforcedSoilTypeEnum.ROLLERCOMPACTED + + +surchargepreloaded = IfcReinforcedSoilTypeEnum.SURCHARGEPRELOADED + + +verticallydrained = IfcReinforcedSoilTypeEnum.VERTICALLYDRAINED + + +userdefined = IfcReinforcedSoilTypeEnum.USERDEFINED + + +notdefined = IfcReinforcedSoilTypeEnum.NOTDEFINED + + +IfcReinforcingBarRoleEnum = enum_namespace() + + +anchoring = IfcReinforcingBarRoleEnum.ANCHORING + + +edge = IfcReinforcingBarRoleEnum.EDGE + + +ligature = IfcReinforcingBarRoleEnum.LIGATURE + + +main = IfcReinforcingBarRoleEnum.MAIN + + +punching = IfcReinforcingBarRoleEnum.PUNCHING + + +ring = IfcReinforcingBarRoleEnum.RING + + +shear = IfcReinforcingBarRoleEnum.SHEAR + + +stud = IfcReinforcingBarRoleEnum.STUD + + +userdefined = IfcReinforcingBarRoleEnum.USERDEFINED + + +notdefined = IfcReinforcingBarRoleEnum.NOTDEFINED + + +IfcReinforcingBarSurfaceEnum = enum_namespace() + + +plain = IfcReinforcingBarSurfaceEnum.PLAIN + + +textured = IfcReinforcingBarSurfaceEnum.TEXTURED + + +IfcReinforcingBarTypeEnum = enum_namespace() + + +anchoring = IfcReinforcingBarTypeEnum.ANCHORING + + +edge = IfcReinforcingBarTypeEnum.EDGE + + +ligature = IfcReinforcingBarTypeEnum.LIGATURE + + +main = IfcReinforcingBarTypeEnum.MAIN + + +punching = IfcReinforcingBarTypeEnum.PUNCHING + + +ring = IfcReinforcingBarTypeEnum.RING + + +shear = IfcReinforcingBarTypeEnum.SHEAR + + +spacebar = IfcReinforcingBarTypeEnum.SPACEBAR + + +stud = IfcReinforcingBarTypeEnum.STUD + + +userdefined = IfcReinforcingBarTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingBarTypeEnum.NOTDEFINED + + +IfcReinforcingMeshTypeEnum = enum_namespace() + + +userdefined = IfcReinforcingMeshTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingMeshTypeEnum.NOTDEFINED + + +IfcRoadPartTypeEnum = enum_namespace() + + +bicyclecrossing = IfcRoadPartTypeEnum.BICYCLECROSSING + + +bus_stop = IfcRoadPartTypeEnum.BUS_STOP + + +carriageway = IfcRoadPartTypeEnum.CARRIAGEWAY + + +centralisland = IfcRoadPartTypeEnum.CENTRALISLAND + + +centralreserve = IfcRoadPartTypeEnum.CENTRALRESERVE + + +hardshoulder = IfcRoadPartTypeEnum.HARDSHOULDER + + +intersection = IfcRoadPartTypeEnum.INTERSECTION + + +layby = IfcRoadPartTypeEnum.LAYBY + + +parkingbay = IfcRoadPartTypeEnum.PARKINGBAY + + +passingbay = IfcRoadPartTypeEnum.PASSINGBAY + + +pedestrian_crossing = IfcRoadPartTypeEnum.PEDESTRIAN_CROSSING + + +railwaycrossing = IfcRoadPartTypeEnum.RAILWAYCROSSING + + +refugeisland = IfcRoadPartTypeEnum.REFUGEISLAND + + +roadsegment = IfcRoadPartTypeEnum.ROADSEGMENT + + +roadside = IfcRoadPartTypeEnum.ROADSIDE + + +roadsidepart = IfcRoadPartTypeEnum.ROADSIDEPART + + +roadwayplateau = IfcRoadPartTypeEnum.ROADWAYPLATEAU + + +roundabout = IfcRoadPartTypeEnum.ROUNDABOUT + + +shoulder = IfcRoadPartTypeEnum.SHOULDER + + +sidewalk = IfcRoadPartTypeEnum.SIDEWALK + + +softshoulder = IfcRoadPartTypeEnum.SOFTSHOULDER + + +tollplaza = IfcRoadPartTypeEnum.TOLLPLAZA + + +trafficisland = IfcRoadPartTypeEnum.TRAFFICISLAND + + +trafficlane = IfcRoadPartTypeEnum.TRAFFICLANE + + +userdefined = IfcRoadPartTypeEnum.USERDEFINED + + +notdefined = IfcRoadPartTypeEnum.NOTDEFINED + + +IfcRoadTypeEnum = enum_namespace() + + +userdefined = IfcRoadTypeEnum.USERDEFINED + + +notdefined = IfcRoadTypeEnum.NOTDEFINED + + +IfcRoleEnum = enum_namespace() + + +architect = IfcRoleEnum.ARCHITECT + + +buildingoperator = IfcRoleEnum.BUILDINGOPERATOR + + +buildingowner = IfcRoleEnum.BUILDINGOWNER + + +civilengineer = IfcRoleEnum.CIVILENGINEER + + +client = IfcRoleEnum.CLIENT + + +commissioningengineer = IfcRoleEnum.COMMISSIONINGENGINEER + + +constructionmanager = IfcRoleEnum.CONSTRUCTIONMANAGER + + +consultant = IfcRoleEnum.CONSULTANT + + +contractor = IfcRoleEnum.CONTRACTOR + + +costengineer = IfcRoleEnum.COSTENGINEER + + +electricalengineer = IfcRoleEnum.ELECTRICALENGINEER + + +engineer = IfcRoleEnum.ENGINEER + + +facilitiesmanager = IfcRoleEnum.FACILITIESMANAGER + + +fieldconstructionmanager = IfcRoleEnum.FIELDCONSTRUCTIONMANAGER + + +manufacturer = IfcRoleEnum.MANUFACTURER + + +mechanicalengineer = IfcRoleEnum.MECHANICALENGINEER + + +owner = IfcRoleEnum.OWNER + + +projectmanager = IfcRoleEnum.PROJECTMANAGER + + +reseller = IfcRoleEnum.RESELLER + + +structuralengineer = IfcRoleEnum.STRUCTURALENGINEER + + +subcontractor = IfcRoleEnum.SUBCONTRACTOR + + +supplier = IfcRoleEnum.SUPPLIER + + +userdefined = IfcRoleEnum.USERDEFINED + + +IfcRoofTypeEnum = enum_namespace() + + +barrel_roof = IfcRoofTypeEnum.BARREL_ROOF + + +butterfly_roof = IfcRoofTypeEnum.BUTTERFLY_ROOF + + +dome_roof = IfcRoofTypeEnum.DOME_ROOF + + +flat_roof = IfcRoofTypeEnum.FLAT_ROOF + + +freeform = IfcRoofTypeEnum.FREEFORM + + +gable_roof = IfcRoofTypeEnum.GABLE_ROOF + + +gambrel_roof = IfcRoofTypeEnum.GAMBREL_ROOF + + +hipped_gable_roof = IfcRoofTypeEnum.HIPPED_GABLE_ROOF + + +hip_roof = IfcRoofTypeEnum.HIP_ROOF + + +mansard_roof = IfcRoofTypeEnum.MANSARD_ROOF + + +pavilion_roof = IfcRoofTypeEnum.PAVILION_ROOF + + +rainbow_roof = IfcRoofTypeEnum.RAINBOW_ROOF + + +shed_roof = IfcRoofTypeEnum.SHED_ROOF + + +userdefined = IfcRoofTypeEnum.USERDEFINED + + +notdefined = IfcRoofTypeEnum.NOTDEFINED + + +IfcSIPrefix = enum_namespace() + + +atto = IfcSIPrefix.ATTO + + +centi = IfcSIPrefix.CENTI + + +deca = IfcSIPrefix.DECA + + +deci = IfcSIPrefix.DECI + + +exa = IfcSIPrefix.EXA + + +femto = IfcSIPrefix.FEMTO + + +giga = IfcSIPrefix.GIGA + + +hecto = IfcSIPrefix.HECTO + + +kilo = IfcSIPrefix.KILO + + +mega = IfcSIPrefix.MEGA + + +micro = IfcSIPrefix.MICRO + + +milli = IfcSIPrefix.MILLI + + +nano = IfcSIPrefix.NANO + + +peta = IfcSIPrefix.PETA + + +pico = IfcSIPrefix.PICO + + +tera = IfcSIPrefix.TERA + + +IfcSIUnitName = enum_namespace() + + +ampere = IfcSIUnitName.AMPERE + + +becquerel = IfcSIUnitName.BECQUEREL + + +candela = IfcSIUnitName.CANDELA + + +coulomb = IfcSIUnitName.COULOMB + + +cubic_metre = IfcSIUnitName.CUBIC_METRE + + +degree_celsius = IfcSIUnitName.DEGREE_CELSIUS + + +farad = IfcSIUnitName.FARAD + + +gram = IfcSIUnitName.GRAM + + +gray = IfcSIUnitName.GRAY + + +henry = IfcSIUnitName.HENRY + + +hertz = IfcSIUnitName.HERTZ + + +joule = IfcSIUnitName.JOULE + + +kelvin = IfcSIUnitName.KELVIN + + +lumen = IfcSIUnitName.LUMEN + + +lux = IfcSIUnitName.LUX + + +metre = IfcSIUnitName.METRE + + +mole = IfcSIUnitName.MOLE + + +newton = IfcSIUnitName.NEWTON + + +ohm = IfcSIUnitName.OHM + + +pascal = IfcSIUnitName.PASCAL + + +radian = IfcSIUnitName.RADIAN + + +second = IfcSIUnitName.SECOND + + +siemens = IfcSIUnitName.SIEMENS + + +sievert = IfcSIUnitName.SIEVERT + + +square_metre = IfcSIUnitName.SQUARE_METRE + + +steradian = IfcSIUnitName.STERADIAN + + +tesla = IfcSIUnitName.TESLA + + +volt = IfcSIUnitName.VOLT + + +watt = IfcSIUnitName.WATT + + +weber = IfcSIUnitName.WEBER + + +IfcSanitaryTerminalTypeEnum = enum_namespace() + + +bath = IfcSanitaryTerminalTypeEnum.BATH + + +bidet = IfcSanitaryTerminalTypeEnum.BIDET + + +cistern = IfcSanitaryTerminalTypeEnum.CISTERN + + +sanitaryfountain = IfcSanitaryTerminalTypeEnum.SANITARYFOUNTAIN + + +shower = IfcSanitaryTerminalTypeEnum.SHOWER + + +sink = IfcSanitaryTerminalTypeEnum.SINK + + +toiletpan = IfcSanitaryTerminalTypeEnum.TOILETPAN + + +urinal = IfcSanitaryTerminalTypeEnum.URINAL + + +washhandbasin = IfcSanitaryTerminalTypeEnum.WASHHANDBASIN + + +wcseat = IfcSanitaryTerminalTypeEnum.WCSEAT + + +userdefined = IfcSanitaryTerminalTypeEnum.USERDEFINED + + +notdefined = IfcSanitaryTerminalTypeEnum.NOTDEFINED + + +IfcSectionTypeEnum = enum_namespace() + + +tapered = IfcSectionTypeEnum.TAPERED + + +uniform = IfcSectionTypeEnum.UNIFORM + + +IfcSensorTypeEnum = enum_namespace() + + +co2sensor = IfcSensorTypeEnum.CO2SENSOR + + +conductancesensor = IfcSensorTypeEnum.CONDUCTANCESENSOR + + +contactsensor = IfcSensorTypeEnum.CONTACTSENSOR + + +cosensor = IfcSensorTypeEnum.COSENSOR + + +earthquakesensor = IfcSensorTypeEnum.EARTHQUAKESENSOR + + +firesensor = IfcSensorTypeEnum.FIRESENSOR + + +flowsensor = IfcSensorTypeEnum.FLOWSENSOR + + +foreignobjectdetectionsensor = IfcSensorTypeEnum.FOREIGNOBJECTDETECTIONSENSOR + + +frostsensor = IfcSensorTypeEnum.FROSTSENSOR + + +gassensor = IfcSensorTypeEnum.GASSENSOR + + +heatsensor = IfcSensorTypeEnum.HEATSENSOR + + +humiditysensor = IfcSensorTypeEnum.HUMIDITYSENSOR + + +identifiersensor = IfcSensorTypeEnum.IDENTIFIERSENSOR + + +ionconcentrationsensor = IfcSensorTypeEnum.IONCONCENTRATIONSENSOR + + +levelsensor = IfcSensorTypeEnum.LEVELSENSOR + + +lightsensor = IfcSensorTypeEnum.LIGHTSENSOR + + +moisturesensor = IfcSensorTypeEnum.MOISTURESENSOR + + +movementsensor = IfcSensorTypeEnum.MOVEMENTSENSOR + + +obstaclesensor = IfcSensorTypeEnum.OBSTACLESENSOR + + +phsensor = IfcSensorTypeEnum.PHSENSOR + + +pressuresensor = IfcSensorTypeEnum.PRESSURESENSOR + + +radiationsensor = IfcSensorTypeEnum.RADIATIONSENSOR + + +radioactivitysensor = IfcSensorTypeEnum.RADIOACTIVITYSENSOR + + +rainsensor = IfcSensorTypeEnum.RAINSENSOR + + +smokesensor = IfcSensorTypeEnum.SMOKESENSOR + + +snowdepthsensor = IfcSensorTypeEnum.SNOWDEPTHSENSOR + + +soundsensor = IfcSensorTypeEnum.SOUNDSENSOR + + +temperaturesensor = IfcSensorTypeEnum.TEMPERATURESENSOR + + +trainsensor = IfcSensorTypeEnum.TRAINSENSOR + + +turnoutclosuresensor = IfcSensorTypeEnum.TURNOUTCLOSURESENSOR + + +wheelsensor = IfcSensorTypeEnum.WHEELSENSOR + + +windsensor = IfcSensorTypeEnum.WINDSENSOR + + +userdefined = IfcSensorTypeEnum.USERDEFINED + + +notdefined = IfcSensorTypeEnum.NOTDEFINED + + +IfcSequenceEnum = enum_namespace() + + +finish_finish = IfcSequenceEnum.FINISH_FINISH + + +finish_start = IfcSequenceEnum.FINISH_START + + +start_finish = IfcSequenceEnum.START_FINISH + + +start_start = IfcSequenceEnum.START_START + + +userdefined = IfcSequenceEnum.USERDEFINED + + +notdefined = IfcSequenceEnum.NOTDEFINED + + +IfcShadingDeviceTypeEnum = enum_namespace() + + +awning = IfcShadingDeviceTypeEnum.AWNING + + +jalousie = IfcShadingDeviceTypeEnum.JALOUSIE + + +shutter = IfcShadingDeviceTypeEnum.SHUTTER + + +userdefined = IfcShadingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcShadingDeviceTypeEnum.NOTDEFINED + + +IfcSignTypeEnum = enum_namespace() + + +marker = IfcSignTypeEnum.MARKER + + +mirror = IfcSignTypeEnum.MIRROR + + +pictoral = IfcSignTypeEnum.PICTORAL + + +userdefined = IfcSignTypeEnum.USERDEFINED + + +notdefined = IfcSignTypeEnum.NOTDEFINED + + +IfcSignalTypeEnum = enum_namespace() + + +audio = IfcSignalTypeEnum.AUDIO + + +mixed = IfcSignalTypeEnum.MIXED + + +visual = IfcSignalTypeEnum.VISUAL + + +userdefined = IfcSignalTypeEnum.USERDEFINED + + +notdefined = IfcSignalTypeEnum.NOTDEFINED + + +IfcSimplePropertyTemplateTypeEnum = enum_namespace() + + +p_boundedvalue = IfcSimplePropertyTemplateTypeEnum.P_BOUNDEDVALUE + + +p_enumeratedvalue = IfcSimplePropertyTemplateTypeEnum.P_ENUMERATEDVALUE + + +p_listvalue = IfcSimplePropertyTemplateTypeEnum.P_LISTVALUE + + +p_referencevalue = IfcSimplePropertyTemplateTypeEnum.P_REFERENCEVALUE + + +p_singlevalue = IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE + + +p_tablevalue = IfcSimplePropertyTemplateTypeEnum.P_TABLEVALUE + + +q_area = IfcSimplePropertyTemplateTypeEnum.Q_AREA + + +q_count = IfcSimplePropertyTemplateTypeEnum.Q_COUNT + + +q_length = IfcSimplePropertyTemplateTypeEnum.Q_LENGTH + + +q_number = IfcSimplePropertyTemplateTypeEnum.Q_NUMBER + + +q_time = IfcSimplePropertyTemplateTypeEnum.Q_TIME + + +q_volume = IfcSimplePropertyTemplateTypeEnum.Q_VOLUME + + +q_weight = IfcSimplePropertyTemplateTypeEnum.Q_WEIGHT + + +IfcSlabTypeEnum = enum_namespace() + + +approach_slab = IfcSlabTypeEnum.APPROACH_SLAB + + +baseslab = IfcSlabTypeEnum.BASESLAB + + +floor = IfcSlabTypeEnum.FLOOR + + +landing = IfcSlabTypeEnum.LANDING + + +paving = IfcSlabTypeEnum.PAVING + + +roof = IfcSlabTypeEnum.ROOF + + +sidewalk = IfcSlabTypeEnum.SIDEWALK + + +trackslab = IfcSlabTypeEnum.TRACKSLAB + + +wearing = IfcSlabTypeEnum.WEARING + + +userdefined = IfcSlabTypeEnum.USERDEFINED + + +notdefined = IfcSlabTypeEnum.NOTDEFINED + + +IfcSolarDeviceTypeEnum = enum_namespace() + + +solarcollector = IfcSolarDeviceTypeEnum.SOLARCOLLECTOR + + +solarpanel = IfcSolarDeviceTypeEnum.SOLARPANEL + + +userdefined = IfcSolarDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSolarDeviceTypeEnum.NOTDEFINED + + +IfcSpaceHeaterTypeEnum = enum_namespace() + + +convector = IfcSpaceHeaterTypeEnum.CONVECTOR + + +radiator = IfcSpaceHeaterTypeEnum.RADIATOR + + +userdefined = IfcSpaceHeaterTypeEnum.USERDEFINED + + +notdefined = IfcSpaceHeaterTypeEnum.NOTDEFINED + + +IfcSpaceTypeEnum = enum_namespace() + + +berth = IfcSpaceTypeEnum.BERTH + + +external = IfcSpaceTypeEnum.EXTERNAL + + +gfa = IfcSpaceTypeEnum.GFA + + +internal = IfcSpaceTypeEnum.INTERNAL + + +parking = IfcSpaceTypeEnum.PARKING + + +space = IfcSpaceTypeEnum.SPACE + + +userdefined = IfcSpaceTypeEnum.USERDEFINED + + +notdefined = IfcSpaceTypeEnum.NOTDEFINED + + +IfcSpatialZoneTypeEnum = enum_namespace() + + +construction = IfcSpatialZoneTypeEnum.CONSTRUCTION + + +firesafety = IfcSpatialZoneTypeEnum.FIRESAFETY + + +interference = IfcSpatialZoneTypeEnum.INTERFERENCE + + +lighting = IfcSpatialZoneTypeEnum.LIGHTING + + +occupancy = IfcSpatialZoneTypeEnum.OCCUPANCY + + +reservation = IfcSpatialZoneTypeEnum.RESERVATION + + +security = IfcSpatialZoneTypeEnum.SECURITY + + +thermal = IfcSpatialZoneTypeEnum.THERMAL + + +transport = IfcSpatialZoneTypeEnum.TRANSPORT + + +ventilation = IfcSpatialZoneTypeEnum.VENTILATION + + +userdefined = IfcSpatialZoneTypeEnum.USERDEFINED + + +notdefined = IfcSpatialZoneTypeEnum.NOTDEFINED + + +IfcStackTerminalTypeEnum = enum_namespace() + + +birdcage = IfcStackTerminalTypeEnum.BIRDCAGE + + +cowl = IfcStackTerminalTypeEnum.COWL + + +rainwaterhopper = IfcStackTerminalTypeEnum.RAINWATERHOPPER + + +userdefined = IfcStackTerminalTypeEnum.USERDEFINED + + +notdefined = IfcStackTerminalTypeEnum.NOTDEFINED + + +IfcStairFlightTypeEnum = enum_namespace() + + +curved = IfcStairFlightTypeEnum.CURVED + + +freeform = IfcStairFlightTypeEnum.FREEFORM + + +spiral = IfcStairFlightTypeEnum.SPIRAL + + +straight = IfcStairFlightTypeEnum.STRAIGHT + + +winder = IfcStairFlightTypeEnum.WINDER + + +userdefined = IfcStairFlightTypeEnum.USERDEFINED + + +notdefined = IfcStairFlightTypeEnum.NOTDEFINED + + +IfcStairTypeEnum = enum_namespace() + + +curved_run_stair = IfcStairTypeEnum.CURVED_RUN_STAIR + + +double_return_stair = IfcStairTypeEnum.DOUBLE_RETURN_STAIR + + +half_turn_stair = IfcStairTypeEnum.HALF_TURN_STAIR + + +half_winding_stair = IfcStairTypeEnum.HALF_WINDING_STAIR + + +ladder = IfcStairTypeEnum.LADDER + + +quarter_turn_stair = IfcStairTypeEnum.QUARTER_TURN_STAIR + + +quarter_winding_stair = IfcStairTypeEnum.QUARTER_WINDING_STAIR + + +spiral_stair = IfcStairTypeEnum.SPIRAL_STAIR + + +straight_run_stair = IfcStairTypeEnum.STRAIGHT_RUN_STAIR + + +three_quarter_turn_stair = IfcStairTypeEnum.THREE_QUARTER_TURN_STAIR + + +three_quarter_winding_stair = IfcStairTypeEnum.THREE_QUARTER_WINDING_STAIR + + +two_curved_run_stair = IfcStairTypeEnum.TWO_CURVED_RUN_STAIR + + +two_quarter_turn_stair = IfcStairTypeEnum.TWO_QUARTER_TURN_STAIR + + +two_quarter_winding_stair = IfcStairTypeEnum.TWO_QUARTER_WINDING_STAIR + + +two_straight_run_stair = IfcStairTypeEnum.TWO_STRAIGHT_RUN_STAIR + + +userdefined = IfcStairTypeEnum.USERDEFINED + + +notdefined = IfcStairTypeEnum.NOTDEFINED + + +IfcStateEnum = enum_namespace() + + +locked = IfcStateEnum.LOCKED + + +readonly = IfcStateEnum.READONLY + + +readonlylocked = IfcStateEnum.READONLYLOCKED + + +readwrite = IfcStateEnum.READWRITE + + +readwritelocked = IfcStateEnum.READWRITELOCKED + + +IfcStructuralCurveActivityTypeEnum = enum_namespace() + + +const = IfcStructuralCurveActivityTypeEnum.CONST + + +discrete = IfcStructuralCurveActivityTypeEnum.DISCRETE + + +equidistant = IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + +linear = IfcStructuralCurveActivityTypeEnum.LINEAR + + +parabola = IfcStructuralCurveActivityTypeEnum.PARABOLA + + +polygonal = IfcStructuralCurveActivityTypeEnum.POLYGONAL + + +sinus = IfcStructuralCurveActivityTypeEnum.SINUS + + +userdefined = IfcStructuralCurveActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveActivityTypeEnum.NOTDEFINED + + +IfcStructuralCurveMemberTypeEnum = enum_namespace() + + +cable = IfcStructuralCurveMemberTypeEnum.CABLE + + +compression_member = IfcStructuralCurveMemberTypeEnum.COMPRESSION_MEMBER + + +pin_joined_member = IfcStructuralCurveMemberTypeEnum.PIN_JOINED_MEMBER + + +rigid_joined_member = IfcStructuralCurveMemberTypeEnum.RIGID_JOINED_MEMBER + + +tension_member = IfcStructuralCurveMemberTypeEnum.TENSION_MEMBER + + +userdefined = IfcStructuralCurveMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveMemberTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceActivityTypeEnum = enum_namespace() + + +bilinear = IfcStructuralSurfaceActivityTypeEnum.BILINEAR + + +const = IfcStructuralSurfaceActivityTypeEnum.CONST + + +discrete = IfcStructuralSurfaceActivityTypeEnum.DISCRETE + + +isocontour = IfcStructuralSurfaceActivityTypeEnum.ISOCONTOUR + + +userdefined = IfcStructuralSurfaceActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceActivityTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceMemberTypeEnum = enum_namespace() + + +bending_element = IfcStructuralSurfaceMemberTypeEnum.BENDING_ELEMENT + + +membrane_element = IfcStructuralSurfaceMemberTypeEnum.MEMBRANE_ELEMENT + + +shell = IfcStructuralSurfaceMemberTypeEnum.SHELL + + +userdefined = IfcStructuralSurfaceMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceMemberTypeEnum.NOTDEFINED + + +IfcSubContractResourceTypeEnum = enum_namespace() + + +purchase = IfcSubContractResourceTypeEnum.PURCHASE + + +work = IfcSubContractResourceTypeEnum.WORK + + +userdefined = IfcSubContractResourceTypeEnum.USERDEFINED + + +notdefined = IfcSubContractResourceTypeEnum.NOTDEFINED + + +IfcSurfaceFeatureTypeEnum = enum_namespace() + + +defect = IfcSurfaceFeatureTypeEnum.DEFECT + + +hatchmarking = IfcSurfaceFeatureTypeEnum.HATCHMARKING + + +linemarking = IfcSurfaceFeatureTypeEnum.LINEMARKING + + +mark = IfcSurfaceFeatureTypeEnum.MARK + + +nonskidsurfacing = IfcSurfaceFeatureTypeEnum.NONSKIDSURFACING + + +pavementsurfacemarking = IfcSurfaceFeatureTypeEnum.PAVEMENTSURFACEMARKING + + +rumblestrip = IfcSurfaceFeatureTypeEnum.RUMBLESTRIP + + +symbolmarking = IfcSurfaceFeatureTypeEnum.SYMBOLMARKING + + +tag = IfcSurfaceFeatureTypeEnum.TAG + + +transverserumblestrip = IfcSurfaceFeatureTypeEnum.TRANSVERSERUMBLESTRIP + + +treatment = IfcSurfaceFeatureTypeEnum.TREATMENT + + +userdefined = IfcSurfaceFeatureTypeEnum.USERDEFINED + + +notdefined = IfcSurfaceFeatureTypeEnum.NOTDEFINED + + +IfcSurfaceSide = enum_namespace() + + +both = IfcSurfaceSide.BOTH + + +negative = IfcSurfaceSide.NEGATIVE + + +positive = IfcSurfaceSide.POSITIVE + + +IfcSwitchingDeviceTypeEnum = enum_namespace() + + +contactor = IfcSwitchingDeviceTypeEnum.CONTACTOR + + +dimmerswitch = IfcSwitchingDeviceTypeEnum.DIMMERSWITCH + + +emergencystop = IfcSwitchingDeviceTypeEnum.EMERGENCYSTOP + + +keypad = IfcSwitchingDeviceTypeEnum.KEYPAD + + +momentaryswitch = IfcSwitchingDeviceTypeEnum.MOMENTARYSWITCH + + +relay = IfcSwitchingDeviceTypeEnum.RELAY + + +selectorswitch = IfcSwitchingDeviceTypeEnum.SELECTORSWITCH + + +starter = IfcSwitchingDeviceTypeEnum.STARTER + + +start_and_stop_equipment = IfcSwitchingDeviceTypeEnum.START_AND_STOP_EQUIPMENT + + +switchdisconnector = IfcSwitchingDeviceTypeEnum.SWITCHDISCONNECTOR + + +toggleswitch = IfcSwitchingDeviceTypeEnum.TOGGLESWITCH + + +userdefined = IfcSwitchingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSwitchingDeviceTypeEnum.NOTDEFINED + + +IfcSystemFurnitureElementTypeEnum = enum_namespace() + + +panel = IfcSystemFurnitureElementTypeEnum.PANEL + + +subrack = IfcSystemFurnitureElementTypeEnum.SUBRACK + + +worksurface = IfcSystemFurnitureElementTypeEnum.WORKSURFACE + + +userdefined = IfcSystemFurnitureElementTypeEnum.USERDEFINED + + +notdefined = IfcSystemFurnitureElementTypeEnum.NOTDEFINED + + +IfcTankTypeEnum = enum_namespace() + + +basin = IfcTankTypeEnum.BASIN + + +breakpressure = IfcTankTypeEnum.BREAKPRESSURE + + +expansion = IfcTankTypeEnum.EXPANSION + + +feedandexpansion = IfcTankTypeEnum.FEEDANDEXPANSION + + +oilretentiontray = IfcTankTypeEnum.OILRETENTIONTRAY + + +pressurevessel = IfcTankTypeEnum.PRESSUREVESSEL + + +storage = IfcTankTypeEnum.STORAGE + + +vessel = IfcTankTypeEnum.VESSEL + + +userdefined = IfcTankTypeEnum.USERDEFINED + + +notdefined = IfcTankTypeEnum.NOTDEFINED + + +IfcTaskDurationEnum = enum_namespace() + + +elapsedtime = IfcTaskDurationEnum.ELAPSEDTIME + + +worktime = IfcTaskDurationEnum.WORKTIME + + +notdefined = IfcTaskDurationEnum.NOTDEFINED + + +IfcTaskTypeEnum = enum_namespace() + + +adjustment = IfcTaskTypeEnum.ADJUSTMENT + + +attendance = IfcTaskTypeEnum.ATTENDANCE + + +calibration = IfcTaskTypeEnum.CALIBRATION + + +construction = IfcTaskTypeEnum.CONSTRUCTION + + +demolition = IfcTaskTypeEnum.DEMOLITION + + +dismantle = IfcTaskTypeEnum.DISMANTLE + + +disposal = IfcTaskTypeEnum.DISPOSAL + + +emergency = IfcTaskTypeEnum.EMERGENCY + + +inspection = IfcTaskTypeEnum.INSPECTION + + +installation = IfcTaskTypeEnum.INSTALLATION + + +logistic = IfcTaskTypeEnum.LOGISTIC + + +maintenance = IfcTaskTypeEnum.MAINTENANCE + + +move = IfcTaskTypeEnum.MOVE + + +operation = IfcTaskTypeEnum.OPERATION + + +removal = IfcTaskTypeEnum.REMOVAL + + +renovation = IfcTaskTypeEnum.RENOVATION + + +safety = IfcTaskTypeEnum.SAFETY + + +shutdown = IfcTaskTypeEnum.SHUTDOWN + + +startup = IfcTaskTypeEnum.STARTUP + + +testing = IfcTaskTypeEnum.TESTING + + +troubleshooting = IfcTaskTypeEnum.TROUBLESHOOTING + + +userdefined = IfcTaskTypeEnum.USERDEFINED + + +notdefined = IfcTaskTypeEnum.NOTDEFINED + + +IfcTendonAnchorTypeEnum = enum_namespace() + + +coupler = IfcTendonAnchorTypeEnum.COUPLER + + +fixed_end = IfcTendonAnchorTypeEnum.FIXED_END + + +tensioning_end = IfcTendonAnchorTypeEnum.TENSIONING_END + + +userdefined = IfcTendonAnchorTypeEnum.USERDEFINED + + +notdefined = IfcTendonAnchorTypeEnum.NOTDEFINED + + +IfcTendonConduitTypeEnum = enum_namespace() + + +coupler = IfcTendonConduitTypeEnum.COUPLER + + +diabolo = IfcTendonConduitTypeEnum.DIABOLO + + +duct = IfcTendonConduitTypeEnum.DUCT + + +grouting_duct = IfcTendonConduitTypeEnum.GROUTING_DUCT + + +trumpet = IfcTendonConduitTypeEnum.TRUMPET + + +userdefined = IfcTendonConduitTypeEnum.USERDEFINED + + +notdefined = IfcTendonConduitTypeEnum.NOTDEFINED + + +IfcTendonTypeEnum = enum_namespace() + + +bar = IfcTendonTypeEnum.BAR + + +coated = IfcTendonTypeEnum.COATED + + +strand = IfcTendonTypeEnum.STRAND + + +wire = IfcTendonTypeEnum.WIRE + + +userdefined = IfcTendonTypeEnum.USERDEFINED + + +notdefined = IfcTendonTypeEnum.NOTDEFINED + + +IfcTextPath = enum_namespace() + + +down = IfcTextPath.DOWN + + +left = IfcTextPath.LEFT + + +right = IfcTextPath.RIGHT + + +up = IfcTextPath.UP + + +IfcTimeSeriesDataTypeEnum = enum_namespace() + + +continuous = IfcTimeSeriesDataTypeEnum.CONTINUOUS + + +discrete = IfcTimeSeriesDataTypeEnum.DISCRETE + + +discretebinary = IfcTimeSeriesDataTypeEnum.DISCRETEBINARY + + +piecewisebinary = IfcTimeSeriesDataTypeEnum.PIECEWISEBINARY + + +piecewiseconstant = IfcTimeSeriesDataTypeEnum.PIECEWISECONSTANT + + +piecewisecontinuous = IfcTimeSeriesDataTypeEnum.PIECEWISECONTINUOUS + + +notdefined = IfcTimeSeriesDataTypeEnum.NOTDEFINED + + +IfcTrackElementTypeEnum = enum_namespace() + + +blockingdevice = IfcTrackElementTypeEnum.BLOCKINGDEVICE + + +derailer = IfcTrackElementTypeEnum.DERAILER + + +frog = IfcTrackElementTypeEnum.FROG + + +half_set_of_blades = IfcTrackElementTypeEnum.HALF_SET_OF_BLADES + + +sleeper = IfcTrackElementTypeEnum.SLEEPER + + +speedregulator = IfcTrackElementTypeEnum.SPEEDREGULATOR + + +trackendofalignment = IfcTrackElementTypeEnum.TRACKENDOFALIGNMENT + + +vehiclestop = IfcTrackElementTypeEnum.VEHICLESTOP + + +userdefined = IfcTrackElementTypeEnum.USERDEFINED + + +notdefined = IfcTrackElementTypeEnum.NOTDEFINED + + +IfcTransformerTypeEnum = enum_namespace() + + +chopper = IfcTransformerTypeEnum.CHOPPER + + +combined = IfcTransformerTypeEnum.COMBINED + + +current = IfcTransformerTypeEnum.CURRENT + + +frequency = IfcTransformerTypeEnum.FREQUENCY + + +inverter = IfcTransformerTypeEnum.INVERTER + + +rectifier = IfcTransformerTypeEnum.RECTIFIER + + +voltage = IfcTransformerTypeEnum.VOLTAGE + + +userdefined = IfcTransformerTypeEnum.USERDEFINED + + +notdefined = IfcTransformerTypeEnum.NOTDEFINED + + +IfcTransitionCode = enum_namespace() + + +continuous = IfcTransitionCode.CONTINUOUS + + +contsamegradient = IfcTransitionCode.CONTSAMEGRADIENT + + +contsamegradientsamecurvature = IfcTransitionCode.CONTSAMEGRADIENTSAMECURVATURE + + +discontinuous = IfcTransitionCode.DISCONTINUOUS + + +IfcTransportElementTypeEnum = enum_namespace() + + +craneway = IfcTransportElementTypeEnum.CRANEWAY + + +elevator = IfcTransportElementTypeEnum.ELEVATOR + + +escalator = IfcTransportElementTypeEnum.ESCALATOR + + +haulinggear = IfcTransportElementTypeEnum.HAULINGGEAR + + +liftinggear = IfcTransportElementTypeEnum.LIFTINGGEAR + + +movingwalkway = IfcTransportElementTypeEnum.MOVINGWALKWAY + + +userdefined = IfcTransportElementTypeEnum.USERDEFINED + + +notdefined = IfcTransportElementTypeEnum.NOTDEFINED + + +IfcTrimmingPreference = enum_namespace() + + +cartesian = IfcTrimmingPreference.CARTESIAN + + +parameter = IfcTrimmingPreference.PARAMETER + + +unspecified = IfcTrimmingPreference.UNSPECIFIED + + +IfcTubeBundleTypeEnum = enum_namespace() + + +finned = IfcTubeBundleTypeEnum.FINNED + + +userdefined = IfcTubeBundleTypeEnum.USERDEFINED + + +notdefined = IfcTubeBundleTypeEnum.NOTDEFINED + + +IfcUnitEnum = enum_namespace() + + +absorbeddoseunit = IfcUnitEnum.ABSORBEDDOSEUNIT + + +amountofsubstanceunit = IfcUnitEnum.AMOUNTOFSUBSTANCEUNIT + + +areaunit = IfcUnitEnum.AREAUNIT + + +doseequivalentunit = IfcUnitEnum.DOSEEQUIVALENTUNIT + + +electriccapacitanceunit = IfcUnitEnum.ELECTRICCAPACITANCEUNIT + + +electricchargeunit = IfcUnitEnum.ELECTRICCHARGEUNIT + + +electricconductanceunit = IfcUnitEnum.ELECTRICCONDUCTANCEUNIT + + +electriccurrentunit = IfcUnitEnum.ELECTRICCURRENTUNIT + + +electricresistanceunit = IfcUnitEnum.ELECTRICRESISTANCEUNIT + + +electricvoltageunit = IfcUnitEnum.ELECTRICVOLTAGEUNIT + + +energyunit = IfcUnitEnum.ENERGYUNIT + + +forceunit = IfcUnitEnum.FORCEUNIT + + +frequencyunit = IfcUnitEnum.FREQUENCYUNIT + + +illuminanceunit = IfcUnitEnum.ILLUMINANCEUNIT + + +inductanceunit = IfcUnitEnum.INDUCTANCEUNIT + + +lengthunit = IfcUnitEnum.LENGTHUNIT + + +luminousfluxunit = IfcUnitEnum.LUMINOUSFLUXUNIT + + +luminousintensityunit = IfcUnitEnum.LUMINOUSINTENSITYUNIT + + +magneticfluxdensityunit = IfcUnitEnum.MAGNETICFLUXDENSITYUNIT + + +magneticfluxunit = IfcUnitEnum.MAGNETICFLUXUNIT + + +massunit = IfcUnitEnum.MASSUNIT + + +planeangleunit = IfcUnitEnum.PLANEANGLEUNIT + + +powerunit = IfcUnitEnum.POWERUNIT + + +pressureunit = IfcUnitEnum.PRESSUREUNIT + + +radioactivityunit = IfcUnitEnum.RADIOACTIVITYUNIT + + +solidangleunit = IfcUnitEnum.SOLIDANGLEUNIT + + +thermodynamictemperatureunit = IfcUnitEnum.THERMODYNAMICTEMPERATUREUNIT + + +timeunit = IfcUnitEnum.TIMEUNIT + + +volumeunit = IfcUnitEnum.VOLUMEUNIT + + +userdefined = IfcUnitEnum.USERDEFINED + + +IfcUnitaryControlElementTypeEnum = enum_namespace() + + +alarmpanel = IfcUnitaryControlElementTypeEnum.ALARMPANEL + + +basestationcontroller = IfcUnitaryControlElementTypeEnum.BASESTATIONCONTROLLER + + +combined = IfcUnitaryControlElementTypeEnum.COMBINED + + +controlpanel = IfcUnitaryControlElementTypeEnum.CONTROLPANEL + + +gasdetectionpanel = IfcUnitaryControlElementTypeEnum.GASDETECTIONPANEL + + +humidistat = IfcUnitaryControlElementTypeEnum.HUMIDISTAT + + +indicatorpanel = IfcUnitaryControlElementTypeEnum.INDICATORPANEL + + +mimicpanel = IfcUnitaryControlElementTypeEnum.MIMICPANEL + + +thermostat = IfcUnitaryControlElementTypeEnum.THERMOSTAT + + +weatherstation = IfcUnitaryControlElementTypeEnum.WEATHERSTATION + + +userdefined = IfcUnitaryControlElementTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryControlElementTypeEnum.NOTDEFINED + + +IfcUnitaryEquipmentTypeEnum = enum_namespace() + + +airconditioningunit = IfcUnitaryEquipmentTypeEnum.AIRCONDITIONINGUNIT + + +airhandler = IfcUnitaryEquipmentTypeEnum.AIRHANDLER + + +dehumidifier = IfcUnitaryEquipmentTypeEnum.DEHUMIDIFIER + + +rooftopunit = IfcUnitaryEquipmentTypeEnum.ROOFTOPUNIT + + +splitsystem = IfcUnitaryEquipmentTypeEnum.SPLITSYSTEM + + +userdefined = IfcUnitaryEquipmentTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryEquipmentTypeEnum.NOTDEFINED + + +IfcValveTypeEnum = enum_namespace() + + +airrelease = IfcValveTypeEnum.AIRRELEASE + + +antivacuum = IfcValveTypeEnum.ANTIVACUUM + + +changeover = IfcValveTypeEnum.CHANGEOVER + + +check = IfcValveTypeEnum.CHECK + + +commissioning = IfcValveTypeEnum.COMMISSIONING + + +diverting = IfcValveTypeEnum.DIVERTING + + +doublecheck = IfcValveTypeEnum.DOUBLECHECK + + +doubleregulating = IfcValveTypeEnum.DOUBLEREGULATING + + +drawoffcock = IfcValveTypeEnum.DRAWOFFCOCK + + +faucet = IfcValveTypeEnum.FAUCET + + +flushing = IfcValveTypeEnum.FLUSHING + + +gascock = IfcValveTypeEnum.GASCOCK + + +gastap = IfcValveTypeEnum.GASTAP + + +isolating = IfcValveTypeEnum.ISOLATING + + +mixing = IfcValveTypeEnum.MIXING + + +pressurereducing = IfcValveTypeEnum.PRESSUREREDUCING + + +pressurerelief = IfcValveTypeEnum.PRESSURERELIEF + + +regulating = IfcValveTypeEnum.REGULATING + + +safetycutoff = IfcValveTypeEnum.SAFETYCUTOFF + + +steamtrap = IfcValveTypeEnum.STEAMTRAP + + +stopcock = IfcValveTypeEnum.STOPCOCK + + +userdefined = IfcValveTypeEnum.USERDEFINED + + +notdefined = IfcValveTypeEnum.NOTDEFINED + + +IfcVehicleTypeEnum = enum_namespace() + + +cargo = IfcVehicleTypeEnum.CARGO + + +rollingstock = IfcVehicleTypeEnum.ROLLINGSTOCK + + +vehicle = IfcVehicleTypeEnum.VEHICLE + + +vehicleair = IfcVehicleTypeEnum.VEHICLEAIR + + +vehiclemarine = IfcVehicleTypeEnum.VEHICLEMARINE + + +vehicletracked = IfcVehicleTypeEnum.VEHICLETRACKED + + +vehiclewheeled = IfcVehicleTypeEnum.VEHICLEWHEELED + + +userdefined = IfcVehicleTypeEnum.USERDEFINED + + +notdefined = IfcVehicleTypeEnum.NOTDEFINED + + +IfcVibrationDamperTypeEnum = enum_namespace() + + +axial_yield = IfcVibrationDamperTypeEnum.AXIAL_YIELD + + +bending_yield = IfcVibrationDamperTypeEnum.BENDING_YIELD + + +friction = IfcVibrationDamperTypeEnum.FRICTION + + +rubber = IfcVibrationDamperTypeEnum.RUBBER + + +shear_yield = IfcVibrationDamperTypeEnum.SHEAR_YIELD + + +viscous = IfcVibrationDamperTypeEnum.VISCOUS + + +userdefined = IfcVibrationDamperTypeEnum.USERDEFINED + + +notdefined = IfcVibrationDamperTypeEnum.NOTDEFINED + + +IfcVibrationIsolatorTypeEnum = enum_namespace() + + +base = IfcVibrationIsolatorTypeEnum.BASE + + +compression = IfcVibrationIsolatorTypeEnum.COMPRESSION + + +spring = IfcVibrationIsolatorTypeEnum.SPRING + + +userdefined = IfcVibrationIsolatorTypeEnum.USERDEFINED + + +notdefined = IfcVibrationIsolatorTypeEnum.NOTDEFINED + + +IfcVirtualElementTypeEnum = enum_namespace() + + +boundary = IfcVirtualElementTypeEnum.BOUNDARY + + +clearance = IfcVirtualElementTypeEnum.CLEARANCE + + +provisionforvoid = IfcVirtualElementTypeEnum.PROVISIONFORVOID + + +userdefined = IfcVirtualElementTypeEnum.USERDEFINED + + +notdefined = IfcVirtualElementTypeEnum.NOTDEFINED + + +IfcVoidingFeatureTypeEnum = enum_namespace() + + +chamfer = IfcVoidingFeatureTypeEnum.CHAMFER + + +cutout = IfcVoidingFeatureTypeEnum.CUTOUT + + +edge = IfcVoidingFeatureTypeEnum.EDGE + + +hole = IfcVoidingFeatureTypeEnum.HOLE + + +miter = IfcVoidingFeatureTypeEnum.MITER + + +notch = IfcVoidingFeatureTypeEnum.NOTCH + + +userdefined = IfcVoidingFeatureTypeEnum.USERDEFINED + + +notdefined = IfcVoidingFeatureTypeEnum.NOTDEFINED + + +IfcWallTypeEnum = enum_namespace() + + +elementedwall = IfcWallTypeEnum.ELEMENTEDWALL + + +movable = IfcWallTypeEnum.MOVABLE + + +parapet = IfcWallTypeEnum.PARAPET + + +partitioning = IfcWallTypeEnum.PARTITIONING + + +plumbingwall = IfcWallTypeEnum.PLUMBINGWALL + + +polygonal = IfcWallTypeEnum.POLYGONAL + + +retainingwall = IfcWallTypeEnum.RETAININGWALL + + +shear = IfcWallTypeEnum.SHEAR + + +solidwall = IfcWallTypeEnum.SOLIDWALL + + +standard = IfcWallTypeEnum.STANDARD + + +wavewall = IfcWallTypeEnum.WAVEWALL + + +userdefined = IfcWallTypeEnum.USERDEFINED + + +notdefined = IfcWallTypeEnum.NOTDEFINED + + +IfcWasteTerminalTypeEnum = enum_namespace() + + +floortrap = IfcWasteTerminalTypeEnum.FLOORTRAP + + +floorwaste = IfcWasteTerminalTypeEnum.FLOORWASTE + + +gullysump = IfcWasteTerminalTypeEnum.GULLYSUMP + + +gullytrap = IfcWasteTerminalTypeEnum.GULLYTRAP + + +roofdrain = IfcWasteTerminalTypeEnum.ROOFDRAIN + + +wastedisposalunit = IfcWasteTerminalTypeEnum.WASTEDISPOSALUNIT + + +wastetrap = IfcWasteTerminalTypeEnum.WASTETRAP + + +userdefined = IfcWasteTerminalTypeEnum.USERDEFINED + + +notdefined = IfcWasteTerminalTypeEnum.NOTDEFINED + + +IfcWindowPanelOperationEnum = enum_namespace() + + +bottomhung = IfcWindowPanelOperationEnum.BOTTOMHUNG + + +fixedcasement = IfcWindowPanelOperationEnum.FIXEDCASEMENT + + +otheroperation = IfcWindowPanelOperationEnum.OTHEROPERATION + + +pivothorizontal = IfcWindowPanelOperationEnum.PIVOTHORIZONTAL + + +pivotvertical = IfcWindowPanelOperationEnum.PIVOTVERTICAL + + +removablecasement = IfcWindowPanelOperationEnum.REMOVABLECASEMENT + + +sidehunglefthand = IfcWindowPanelOperationEnum.SIDEHUNGLEFTHAND + + +sidehungrighthand = IfcWindowPanelOperationEnum.SIDEHUNGRIGHTHAND + + +slidinghorizontal = IfcWindowPanelOperationEnum.SLIDINGHORIZONTAL + + +slidingvertical = IfcWindowPanelOperationEnum.SLIDINGVERTICAL + + +tiltandturnlefthand = IfcWindowPanelOperationEnum.TILTANDTURNLEFTHAND + + +tiltandturnrighthand = IfcWindowPanelOperationEnum.TILTANDTURNRIGHTHAND + + +tophung = IfcWindowPanelOperationEnum.TOPHUNG + + +notdefined = IfcWindowPanelOperationEnum.NOTDEFINED + + +IfcWindowPanelPositionEnum = enum_namespace() + + +bottom = IfcWindowPanelPositionEnum.BOTTOM + + +left = IfcWindowPanelPositionEnum.LEFT + + +middle = IfcWindowPanelPositionEnum.MIDDLE + + +right = IfcWindowPanelPositionEnum.RIGHT + + +top = IfcWindowPanelPositionEnum.TOP + + +notdefined = IfcWindowPanelPositionEnum.NOTDEFINED + + +IfcWindowTypeEnum = enum_namespace() + + +lightdome = IfcWindowTypeEnum.LIGHTDOME + + +skylight = IfcWindowTypeEnum.SKYLIGHT + + +window = IfcWindowTypeEnum.WINDOW + + +userdefined = IfcWindowTypeEnum.USERDEFINED + + +notdefined = IfcWindowTypeEnum.NOTDEFINED + + +IfcWindowTypePartitioningEnum = enum_namespace() + + +double_panel_horizontal = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_HORIZONTAL + + +double_panel_vertical = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_VERTICAL + + +single_panel = IfcWindowTypePartitioningEnum.SINGLE_PANEL + + +triple_panel_bottom = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_horizontal = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_HORIZONTAL + + +triple_panel_left = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_top = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_TOP + + +triple_panel_vertical = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_VERTICAL + + +userdefined = IfcWindowTypePartitioningEnum.USERDEFINED + + +notdefined = IfcWindowTypePartitioningEnum.NOTDEFINED + + +IfcWorkCalendarTypeEnum = enum_namespace() + + +firstshift = IfcWorkCalendarTypeEnum.FIRSTSHIFT + + +secondshift = IfcWorkCalendarTypeEnum.SECONDSHIFT + + +thirdshift = IfcWorkCalendarTypeEnum.THIRDSHIFT + + +userdefined = IfcWorkCalendarTypeEnum.USERDEFINED + + +notdefined = IfcWorkCalendarTypeEnum.NOTDEFINED + + +IfcWorkPlanTypeEnum = enum_namespace() + + +actual = IfcWorkPlanTypeEnum.ACTUAL + + +baseline = IfcWorkPlanTypeEnum.BASELINE + + +planned = IfcWorkPlanTypeEnum.PLANNED + + +userdefined = IfcWorkPlanTypeEnum.USERDEFINED + + +notdefined = IfcWorkPlanTypeEnum.NOTDEFINED + + +IfcWorkScheduleTypeEnum = enum_namespace() + + +actual = IfcWorkScheduleTypeEnum.ACTUAL + + +baseline = IfcWorkScheduleTypeEnum.BASELINE + + +planned = IfcWorkScheduleTypeEnum.PLANNED + + +userdefined = IfcWorkScheduleTypeEnum.USERDEFINED + + +notdefined = IfcWorkScheduleTypeEnum.NOTDEFINED + + +def IfcActionRequest(*args, **kwargs): return ifcopenshell.create_entity('IfcActionRequest', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcActor(*args, **kwargs): return ifcopenshell.create_entity('IfcActor', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcActorRole(*args, **kwargs): return ifcopenshell.create_entity('IfcActorRole', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcActuator(*args, **kwargs): return ifcopenshell.create_entity('IfcActuator', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcActuatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcActuatorType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcAddress', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAdvancedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrep', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAdvancedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrepWithVoids', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAdvancedFace(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedFace', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAirTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminal', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAirTerminalBox(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBox', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAirTerminalBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBoxType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAirTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAirToAirHeatRecovery(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecovery', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAirToAirHeatRecoveryType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecoveryType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAlarm(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarm', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAlarmType(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarmType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAlignment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAlignmentCant(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCant', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAlignmentCantSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCantSegment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAlignmentHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentHorizontal', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAlignmentHorizontalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentHorizontalSegment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAlignmentParameterSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentParameterSegment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAlignmentSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentSegment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAlignmentVertical(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentVertical', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAlignmentVerticalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentVerticalSegment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAnnotation(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotation', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAnnotationFillArea(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationFillArea', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcApplication(*args, **kwargs): return ifcopenshell.create_entity('IfcApplication', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAppliedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcAppliedValue', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcApproval', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcApprovalRelationship', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcArbitraryClosedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryClosedProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcArbitraryOpenProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryOpenProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcArbitraryProfileDefWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryProfileDefWithVoids', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAsset(*args, **kwargs): return ifcopenshell.create_entity('IfcAsset', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAsymmetricIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcAsymmetricIShapeProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAudioVisualAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualAppliance', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAudioVisualApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualApplianceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAxis1Placement(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis1Placement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAxis2Placement2D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement2D', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAxis2Placement3D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement3D', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcAxis2PlacementLinear(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2PlacementLinear', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBSplineCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurveWithKnots', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBSplineSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurface', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurfaceWithKnots', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcBeam', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBearing(*args, **kwargs): return ifcopenshell.create_entity('IfcBearing', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBearingType(*args, **kwargs): return ifcopenshell.create_entity('IfcBearingType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBlobTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcBlobTexture', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBlock(*args, **kwargs): return ifcopenshell.create_entity('IfcBlock', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBoiler(*args, **kwargs): return ifcopenshell.create_entity('IfcBoiler', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBoilerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBoilerType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBooleanClippingResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanClippingResult', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBooleanResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanResult', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBorehole(*args, **kwargs): return ifcopenshell.create_entity('IfcBorehole', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBoundaryCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCondition', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBoundaryEdgeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryEdgeCondition', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBoundaryFaceCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryFaceCondition', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBoundaryNodeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeCondition', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBoundaryNodeConditionWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeConditionWarping', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBoundedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedSurface', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBoundingBox(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundingBox', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBoxedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcBoxedHalfSpace', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBridge(*args, **kwargs): return ifcopenshell.create_entity('IfcBridge', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBridgePart(*args, **kwargs): return ifcopenshell.create_entity('IfcBridgePart', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBuilding(*args, **kwargs): return ifcopenshell.create_entity('IfcBuilding', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBuildingElementPart(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPart', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBuildingElementPartType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPartType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBuildingElementProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxy', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBuildingElementProxyType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxyType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBuildingStorey(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingStorey', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBuildingSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingSystem', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBuiltElement(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBuiltElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBuiltSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltSystem', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBurner(*args, **kwargs): return ifcopenshell.create_entity('IfcBurner', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcBurnerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBurnerType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCShapeProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCableCarrierFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFitting', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCableCarrierFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFittingType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCableCarrierSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCableCarrierSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegmentType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCableFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFitting', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCableFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFittingType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCableSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCableSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegmentType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCaissonFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundation', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCaissonFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundationType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCartesianPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPoint', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCartesianPointList(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCartesianPointList2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList2D', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCartesianPointList3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList3D', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCartesianTransformationOperator(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCartesianTransformationOperator2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2D', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCartesianTransformationOperator2DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2DnonUniform', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCartesianTransformationOperator3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3D', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCartesianTransformationOperator3DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3DnonUniform', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCenterLineProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCenterLineProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcChiller(*args, **kwargs): return ifcopenshell.create_entity('IfcChiller', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcChillerType(*args, **kwargs): return ifcopenshell.create_entity('IfcChillerType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcChimney(*args, **kwargs): return ifcopenshell.create_entity('IfcChimney', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcChimneyType(*args, **kwargs): return ifcopenshell.create_entity('IfcChimneyType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCircle(*args, **kwargs): return ifcopenshell.create_entity('IfcCircle', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCircleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleHollowProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCircleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCivilElement(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCivilElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcClassification', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcClassificationReference(*args, **kwargs): return ifcopenshell.create_entity('IfcClassificationReference', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcClosedShell(*args, **kwargs): return ifcopenshell.create_entity('IfcClosedShell', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcClothoid(*args, **kwargs): return ifcopenshell.create_entity('IfcClothoid', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCoil(*args, **kwargs): return ifcopenshell.create_entity('IfcCoil', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCoilType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoilType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcColourRgb(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgb', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcColourRgbList(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgbList', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcColourSpecification(*args, **kwargs): return ifcopenshell.create_entity('IfcColourSpecification', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcColumn', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcColumnType(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsAppliance', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsApplianceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcComplexProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexProperty', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcComplexPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexPropertyTemplate', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCompositeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCompositeCurveOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveOnSurface', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveSegment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCompositeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCompressor(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressor', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCompressorType(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressorType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCondenser(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenser', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCondenserType(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenserType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConic(*args, **kwargs): return ifcopenshell.create_entity('IfcConic', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConnectedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectedFaceSet', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConnectionCurveGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionCurveGeometry', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConnectionGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionGeometry', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConnectionPointEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointEccentricity', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConnectionPointGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointGeometry', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConnectionSurfaceGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionSurfaceGeometry', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConnectionVolumeGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionVolumeGeometry', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcConstraint', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConstructionEquipmentResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResource', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConstructionEquipmentResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResourceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConstructionMaterialResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResource', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConstructionMaterialResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResourceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConstructionProductResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResource', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConstructionProductResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResourceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConstructionResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResource', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConstructionResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResourceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcContext(*args, **kwargs): return ifcopenshell.create_entity('IfcContext', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcContextDependentUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcContextDependentUnit', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcControl(*args, **kwargs): return ifcopenshell.create_entity('IfcControl', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcController(*args, **kwargs): return ifcopenshell.create_entity('IfcController', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcControllerType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConversionBasedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnit', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConversionBasedUnitWithOffset(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnitWithOffset', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConveyorSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcConveyorSegment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcConveyorSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcConveyorSegmentType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCooledBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeam', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCooledBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeamType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCoolingTower(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTower', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCoolingTowerType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTowerType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCoordinateOperation(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateOperation', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCoordinateReferenceSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateReferenceSystem', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCosineSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcCosineSpiral', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCostItem(*args, **kwargs): return ifcopenshell.create_entity('IfcCostItem', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCostSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcCostSchedule', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCostValue(*args, **kwargs): return ifcopenshell.create_entity('IfcCostValue', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCourse(*args, **kwargs): return ifcopenshell.create_entity('IfcCourse', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCourseType(*args, **kwargs): return ifcopenshell.create_entity('IfcCourseType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCovering(*args, **kwargs): return ifcopenshell.create_entity('IfcCovering', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCoveringType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoveringType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCrewResource(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResource', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCrewResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResourceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCsgPrimitive3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgPrimitive3D', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCsgSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgSolid', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCurrencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcCurrencyRelationship', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCurtainWall(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWall', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCurtainWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWallType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCurveBoundedPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedPlane', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCurveBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedSurface', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveSegment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCurveStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyle', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCurveStyleFont(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFont', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCurveStyleFontAndScaling(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontAndScaling', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCurveStyleFontPattern(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontPattern', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcCylindricalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCylindricalSurface', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcDamper', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcDamperType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDeepFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundation', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDeepFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundationType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDerivedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDerivedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnit', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDerivedUnitElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnitElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDimensionalExponents(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionalExponents', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDirection(*args, **kwargs): return ifcopenshell.create_entity('IfcDirection', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDirectrixCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcDirectrixCurveSweptAreaSolid', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDirectrixDerivedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcDirectrixDerivedReferenceSweptAreaSolid', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDiscreteAccessory(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessory', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDiscreteAccessoryType(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessoryType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionBoard', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionBoardType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDistributionChamberElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDistributionChamberElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDistributionCircuit(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionCircuit', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDistributionControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDistributionControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDistributionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDistributionElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDistributionFlowElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDistributionFlowElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDistributionPort(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionPort', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDistributionSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionSystem', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDocumentInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformation', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDocumentInformationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformationRelationship', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDocumentReference(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentReference', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDoor(*args, **kwargs): return ifcopenshell.create_entity('IfcDoor', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDoorLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorLiningProperties', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDoorPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorPanelProperties', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDoorType(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDraughtingPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedColour', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDraughtingPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedCurveFont', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDuctFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFitting', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDuctFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFittingType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDuctSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDuctSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegmentType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDuctSilencer(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencer', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcDuctSilencerType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencerType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEarthworksCut(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksCut', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEarthworksElement(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEarthworksFill(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksFill', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcEdge', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEdgeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEdgeLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeLoop', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElectricAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricAppliance', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElectricApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricApplianceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElectricDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoard', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElectricDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoardType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElectricFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDevice', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElectricFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDeviceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElectricFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowTreatmentDevice', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElectricFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowTreatmentDeviceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElectricGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGenerator', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElectricGeneratorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGeneratorType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElectricMotor(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotor', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElectricMotorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotorType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElectricTimeControl(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControl', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElectricTimeControlType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControlType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElement(*args, **kwargs): return ifcopenshell.create_entity('IfcElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElementAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssembly', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElementAssemblyType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssemblyType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElementComponent(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponent', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElementComponentType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponentType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElementQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcElementQuantity', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcElementarySurface(*args, **kwargs): return ifcopenshell.create_entity('IfcElementarySurface', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEllipse(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipse', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEllipseProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipseProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEnergyConversionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDevice', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEnergyConversionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDeviceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEngine(*args, **kwargs): return ifcopenshell.create_entity('IfcEngine', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEngineType(*args, **kwargs): return ifcopenshell.create_entity('IfcEngineType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEvaporativeCooler(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCooler', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEvaporativeCoolerType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCoolerType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEvaporator(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporator', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEvaporatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporatorType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEvent(*args, **kwargs): return ifcopenshell.create_entity('IfcEvent', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEventTime(*args, **kwargs): return ifcopenshell.create_entity('IfcEventTime', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcEventType(*args, **kwargs): return ifcopenshell.create_entity('IfcEventType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcExtendedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcExtendedProperties', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcExternalInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalInformation', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcExternalReference(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReference', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcExternalReferenceRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReferenceRelationship', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcExternalSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcExternalSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialStructureElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcExternallyDefinedHatchStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedHatchStyle', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcExternallyDefinedSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedSurfaceStyle', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcExternallyDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedTextFont', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcExtrudedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolid', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcExtrudedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolidTapered', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFace(*args, **kwargs): return ifcopenshell.create_entity('IfcFace', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFaceBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBasedSurfaceModel', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFaceBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBound', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFaceOuterBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceOuterBound', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFaceSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceSurface', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFacetedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrep', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFacetedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrepWithVoids', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFacility(*args, **kwargs): return ifcopenshell.create_entity('IfcFacility', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFacilityPart(*args, **kwargs): return ifcopenshell.create_entity('IfcFacilityPart', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFacilityPartCommon(*args, **kwargs): return ifcopenshell.create_entity('IfcFacilityPartCommon', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFailureConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcFailureConnectionCondition', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFan(*args, **kwargs): return ifcopenshell.create_entity('IfcFan', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFanType(*args, **kwargs): return ifcopenshell.create_entity('IfcFanType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcFastener', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFastenerType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFeatureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFeatureElementAddition(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementAddition', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFeatureElementSubtraction(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementSubtraction', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFillAreaStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyle', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFillAreaStyleHatching(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleHatching', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFillAreaStyleTiles(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleTiles', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFilter(*args, **kwargs): return ifcopenshell.create_entity('IfcFilter', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFilterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFilterType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFireSuppressionTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminal', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFireSuppressionTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminalType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFixedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcFixedReferenceSweptAreaSolid', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowController(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowController', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowControllerType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFitting', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFittingType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowInstrument(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrument', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowInstrumentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrumentType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowMeter(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeter', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowMeterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeterType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowMovingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDevice', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowMovingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDeviceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegmentType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDevice', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDeviceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminal', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminalType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDevice', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDeviceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFooting(*args, **kwargs): return ifcopenshell.create_entity('IfcFooting', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFootingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFootingType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFurnishingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFurnishingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFurniture(*args, **kwargs): return ifcopenshell.create_entity('IfcFurniture', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcFurnitureType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnitureType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGeographicCRS(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicCRS', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGeographicElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGeographicElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGeometricCurveSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricCurveSet', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGeometricRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationContext', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGeometricRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationItem', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGeometricRepresentationSubContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationSubContext', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGeometricSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricSet', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGeomodel(*args, **kwargs): return ifcopenshell.create_entity('IfcGeomodel', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGeoslice(*args, **kwargs): return ifcopenshell.create_entity('IfcGeoslice', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGeotechnicalAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalAssembly', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGeotechnicalElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGeotechnicalStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalStratum', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGradientCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcGradientCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGrid(*args, **kwargs): return ifcopenshell.create_entity('IfcGrid', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGridAxis(*args, **kwargs): return ifcopenshell.create_entity('IfcGridAxis', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGridPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcGridPlacement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcGroup', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcHalfSpaceSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcHalfSpaceSolid', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcHeatExchanger(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchanger', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcHeatExchangerType(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchangerType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcHumidifier(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifier', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcHumidifierType(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifierType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcIShapeProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcImageTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcImageTexture', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcImpactProtectionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcImpactProtectionDevice', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcImpactProtectionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcImpactProtectionDeviceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcIndexedColourMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedColourMap', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcIndexedPolyCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolyCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcIndexedPolygonalFace(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFace', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcIndexedPolygonalFaceWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFaceWithVoids', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcIndexedPolygonalTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalTextureMap', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcIndexedTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTextureMap', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcIndexedTriangleTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTriangleTextureMap', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcInterceptor(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptor', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcInterceptorType(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptorType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcIntersectionCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIntersectionCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcInventory(*args, **kwargs): return ifcopenshell.create_entity('IfcInventory', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcIrregularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeries', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcIrregularTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeriesValue', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcJunctionBox(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBox', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcJunctionBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBoxType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcKerb(*args, **kwargs): return ifcopenshell.create_entity('IfcKerb', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcKerbType(*args, **kwargs): return ifcopenshell.create_entity('IfcKerbType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcLShapeProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLaborResource(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResource', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLaborResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResourceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLagTime(*args, **kwargs): return ifcopenshell.create_entity('IfcLagTime', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLamp(*args, **kwargs): return ifcopenshell.create_entity('IfcLamp', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLampType(*args, **kwargs): return ifcopenshell.create_entity('IfcLampType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLibraryInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryInformation', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLibraryReference(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryReference', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLightDistributionData(*args, **kwargs): return ifcopenshell.create_entity('IfcLightDistributionData', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLightFixture(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixture', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLightFixtureType(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixtureType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLightIntensityDistribution(*args, **kwargs): return ifcopenshell.create_entity('IfcLightIntensityDistribution', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLightSource(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSource', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLightSourceAmbient(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceAmbient', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLightSourceDirectional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceDirectional', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLightSourceGoniometric(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceGoniometric', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLightSourcePositional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourcePositional', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLightSourceSpot(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceSpot', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLine(*args, **kwargs): return ifcopenshell.create_entity('IfcLine', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLinearElement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLinearPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPlacement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLinearPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPositioningElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLiquidTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcLiquidTerminal', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLiquidTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcLiquidTerminalType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLocalPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLocalPlacement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcLoop', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcManifoldSolidBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcManifoldSolidBrep', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMapConversion(*args, **kwargs): return ifcopenshell.create_entity('IfcMapConversion', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMapConversionScaled(*args, **kwargs): return ifcopenshell.create_entity('IfcMapConversionScaled', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMappedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcMappedItem', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMarineFacility(*args, **kwargs): return ifcopenshell.create_entity('IfcMarineFacility', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMarinePart(*args, **kwargs): return ifcopenshell.create_entity('IfcMarinePart', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterial', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialClassificationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialClassificationRelationship', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialConstituent(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituent', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialConstituentSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituentSet', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinition', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialDefinitionRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinitionRepresentation', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialLayer(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayer', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialLayerSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSet', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialLayerSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSetUsage', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialLayerWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerWithOffsets', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialList(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialList', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialProfile(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfile', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialProfileSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSet', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialProfileSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsage', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialProfileSetUsageTapering(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsageTapering', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialProfileWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileWithOffsets', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProperties', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialRelationship', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMaterialUsageDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialUsageDefinition', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMeasureWithUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMeasureWithUnit', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMechanicalFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastener', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMechanicalFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastenerType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMedicalDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDevice', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMedicalDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDeviceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMember(*args, **kwargs): return ifcopenshell.create_entity('IfcMember', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMemberType(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMetric(*args, **kwargs): return ifcopenshell.create_entity('IfcMetric', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMirroredProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcMirroredProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMobileTelecommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcMobileTelecommunicationsAppliance', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMobileTelecommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMobileTelecommunicationsApplianceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMonetaryUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMonetaryUnit', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMooringDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMooringDevice', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMooringDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMooringDeviceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMotorConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnection', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcMotorConnectionType(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnectionType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcNamedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcNamedUnit', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcNavigationElement(*args, **kwargs): return ifcopenshell.create_entity('IfcNavigationElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcNavigationElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcNavigationElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcObject(*args, **kwargs): return ifcopenshell.create_entity('IfcObject', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcObjectDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectDefinition', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcObjectPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectPlacement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcObjective(*args, **kwargs): return ifcopenshell.create_entity('IfcObjective', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcOccupant(*args, **kwargs): return ifcopenshell.create_entity('IfcOccupant', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcOffsetCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcOffsetCurve2D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve2D', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcOffsetCurve3D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve3D', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcOffsetCurveByDistances(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurveByDistances', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcOpenCrossProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenCrossProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcOpenShell(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenShell', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcOpeningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganization', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcOrganizationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganizationRelationship', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcOrientedEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcOrientedEdge', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcOuterBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOuterBoundaryCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcOutlet(*args, **kwargs): return ifcopenshell.create_entity('IfcOutlet', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcOutletType(*args, **kwargs): return ifcopenshell.create_entity('IfcOutletType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcOwnerHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcOwnerHistory', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcParameterizedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcParameterizedProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPath(*args, **kwargs): return ifcopenshell.create_entity('IfcPath', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPavement(*args, **kwargs): return ifcopenshell.create_entity('IfcPavement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPavementType(*args, **kwargs): return ifcopenshell.create_entity('IfcPavementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPcurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPcurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPerformanceHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcPerformanceHistory', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPermeableCoveringProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPermeableCoveringProperties', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPermit(*args, **kwargs): return ifcopenshell.create_entity('IfcPermit', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPerson(*args, **kwargs): return ifcopenshell.create_entity('IfcPerson', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPersonAndOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcPersonAndOrganization', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPhysicalComplexQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalComplexQuantity', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPhysicalQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalQuantity', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPhysicalSimpleQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalSimpleQuantity', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPile(*args, **kwargs): return ifcopenshell.create_entity('IfcPile', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPileType(*args, **kwargs): return ifcopenshell.create_entity('IfcPileType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPipeFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFitting', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPipeFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFittingType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPipeSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPipeSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegmentType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPixelTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcPixelTexture', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcPlacement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPlanarBox(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarBox', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPlanarExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarExtent', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcPlane', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPlate(*args, **kwargs): return ifcopenshell.create_entity('IfcPlate', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPlateType(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcPoint', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPointByDistanceExpression(*args, **kwargs): return ifcopenshell.create_entity('IfcPointByDistanceExpression', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPointOnCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPointOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnSurface', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPolyLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyLoop', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPolygonalBoundedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalBoundedHalfSpace', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPolygonalFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalFaceSet', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPolyline(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyline', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPolynomialCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPolynomialCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPort(*args, **kwargs): return ifcopenshell.create_entity('IfcPort', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcPositioningElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPostalAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcPostalAddress', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedColour', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedCurveFont', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPreDefinedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedItem', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPreDefinedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedProperties', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPreDefinedPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedPropertySet', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPreDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedTextFont', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationItem', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPresentationLayerAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerAssignment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPresentationLayerWithStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerWithStyle', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPresentationStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyle', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProcedure(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedure', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProcedureType(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedureType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcProcess', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcProduct', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProductDefinitionShape(*args, **kwargs): return ifcopenshell.create_entity('IfcProductDefinitionShape', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProductRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcProductRepresentation', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileProperties', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProject(*args, **kwargs): return ifcopenshell.create_entity('IfcProject', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProjectLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectLibrary', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProjectOrder(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectOrder', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProjectedCRS(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectedCRS', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProjectionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectionElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcProperty', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPropertyAbstraction(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyAbstraction', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPropertyBoundedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyBoundedValue', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPropertyDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDefinition', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPropertyDependencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDependencyRelationship', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPropertyEnumeratedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeratedValue', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPropertyEnumeration(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeration', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPropertyListValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyListValue', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPropertyReferenceValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyReferenceValue', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySet', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPropertySetDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetDefinition', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPropertySetTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetTemplate', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPropertySingleValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySingleValue', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPropertyTableValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTableValue', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplate', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPropertyTemplateDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplateDefinition', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProtectiveDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDevice', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnit', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnitType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnitType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcProtectiveDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPump(*args, **kwargs): return ifcopenshell.create_entity('IfcPump', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcPumpType(*args, **kwargs): return ifcopenshell.create_entity('IfcPumpType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcQuantityArea(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityArea', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcQuantityCount(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityCount', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcQuantityLength(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityLength', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcQuantityNumber(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityNumber', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcQuantitySet(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantitySet', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcQuantityTime(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityTime', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcQuantityVolume(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityVolume', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcQuantityWeight(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityWeight', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRail(*args, **kwargs): return ifcopenshell.create_entity('IfcRail', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRailType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRailing(*args, **kwargs): return ifcopenshell.create_entity('IfcRailing', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRailingType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailingType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRailway(*args, **kwargs): return ifcopenshell.create_entity('IfcRailway', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRailwayPart(*args, **kwargs): return ifcopenshell.create_entity('IfcRailwayPart', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRamp(*args, **kwargs): return ifcopenshell.create_entity('IfcRamp', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRampFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlight', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRampFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlightType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRampType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRationalBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineCurveWithKnots', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRationalBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineSurfaceWithKnots', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRectangleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleHollowProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRectangularPyramid(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularPyramid', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRectangularTrimmedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularTrimmedSurface', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRecurrencePattern(*args, **kwargs): return ifcopenshell.create_entity('IfcRecurrencePattern', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcReference(*args, **kwargs): return ifcopenshell.create_entity('IfcReference', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcReferent(*args, **kwargs): return ifcopenshell.create_entity('IfcReferent', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRegularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcRegularTimeSeries', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcReinforcedSoil(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcedSoil', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcReinforcementBarProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementBarProperties', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcReinforcementDefinitionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementDefinitionProperties', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcReinforcingBar(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBar', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcReinforcingBarType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBarType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcReinforcingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcReinforcingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcReinforcingMesh(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMesh', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcReinforcingMeshType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMeshType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAdheresToElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAdheresToElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAggregates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAggregates', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssigns(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssigns', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssignsToActor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToActor', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssignsToControl(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToControl', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssignsToGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroup', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssignsToGroupByFactor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroupByFactor', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssignsToProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProcess', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssignsToProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProduct', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssignsToResource(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToResource', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssociates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociates', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssociatesApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesApproval', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssociatesClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesClassification', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssociatesConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesConstraint', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssociatesDocument(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesDocument', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssociatesLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesLibrary', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssociatesMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesMaterial', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelAssociatesProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelConnects(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnects', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelConnectsElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsElements', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelConnectsPathElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPathElements', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelConnectsPortToElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPortToElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelConnectsPorts(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPorts', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelConnectsStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralActivity', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelConnectsStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralMember', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelConnectsWithEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithEccentricity', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelConnectsWithRealizingElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithRealizingElements', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelContainedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelContainedInSpatialStructure', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelCoversBldgElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversBldgElements', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelCoversSpaces(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversSpaces', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelDeclares(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDeclares', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelDecomposes(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDecomposes', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelDefines(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefines', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelDefinesByObject(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByObject', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelDefinesByProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByProperties', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelDefinesByTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByTemplate', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelDefinesByType(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelFillsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFillsElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelFlowControlElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFlowControlElements', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelInterferesElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelInterferesElements', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelNests(*args, **kwargs): return ifcopenshell.create_entity('IfcRelNests', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelPositions(*args, **kwargs): return ifcopenshell.create_entity('IfcRelPositions', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelProjectsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelProjectsElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelReferencedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelReferencedInSpatialStructure', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelSequence(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSequence', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelServicesBuildings(*args, **kwargs): return ifcopenshell.create_entity('IfcRelServicesBuildings', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelSpaceBoundary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelSpaceBoundary1stLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary1stLevel', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelSpaceBoundary2ndLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary2ndLevel', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelVoidsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelVoidsElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcRelationship', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcReparametrisedCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcReparametrisedCompositeCurveSegment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentation', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationContext', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationItem', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRepresentationMap(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationMap', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcResource(*args, **kwargs): return ifcopenshell.create_entity('IfcResource', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcResourceApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceApprovalRelationship', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcResourceConstraintRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceConstraintRelationship', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcResourceLevelRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceLevelRelationship', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcResourceTime(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceTime', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRevolvedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolid', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRevolvedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolidTapered', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRightCircularCone(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCone', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRightCircularCylinder(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCylinder', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRigidOperation(*args, **kwargs): return ifcopenshell.create_entity('IfcRigidOperation', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRoad(*args, **kwargs): return ifcopenshell.create_entity('IfcRoad', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRoadPart(*args, **kwargs): return ifcopenshell.create_entity('IfcRoadPart', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRoof(*args, **kwargs): return ifcopenshell.create_entity('IfcRoof', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRoofType(*args, **kwargs): return ifcopenshell.create_entity('IfcRoofType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRoot(*args, **kwargs): return ifcopenshell.create_entity('IfcRoot', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcRoundedRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRoundedRectangleProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSIUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcSIUnit', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSanitaryTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminal', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSanitaryTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminalType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSchedulingTime(*args, **kwargs): return ifcopenshell.create_entity('IfcSchedulingTime', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSeamCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSeamCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSecondOrderPolynomialSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSecondOrderPolynomialSpiral', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSectionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionProperties', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSectionReinforcementProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionReinforcementProperties', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSectionedSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolid', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSectionedSolidHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolidHorizontal', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSectionedSpine(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSpine', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSectionedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSurface', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcSegment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSegmentedReferenceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSegmentedReferenceCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSensor(*args, **kwargs): return ifcopenshell.create_entity('IfcSensor', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSensorType(*args, **kwargs): return ifcopenshell.create_entity('IfcSensorType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSeventhOrderPolynomialSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSeventhOrderPolynomialSpiral', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcShadingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDevice', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcShadingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDeviceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcShapeAspect(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeAspect', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcShapeModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeModel', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcShapeRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeRepresentation', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcShellBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShellBasedSurfaceModel', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSign(*args, **kwargs): return ifcopenshell.create_entity('IfcSign', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSignType(*args, **kwargs): return ifcopenshell.create_entity('IfcSignType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSignal(*args, **kwargs): return ifcopenshell.create_entity('IfcSignal', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSignalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSignalType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSimpleProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcSimpleProperty', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSimplePropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcSimplePropertyTemplate', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSineSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSineSpiral', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSite(*args, **kwargs): return ifcopenshell.create_entity('IfcSite', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSlab(*args, **kwargs): return ifcopenshell.create_entity('IfcSlab', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSlabType(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSlippageConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcSlippageConnectionCondition', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSolarDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDevice', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSolarDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDeviceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSolidModel(*args, **kwargs): return ifcopenshell.create_entity('IfcSolidModel', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcSpace', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSpaceHeater(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeater', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSpaceHeaterType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeaterType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSpaceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSpatialElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSpatialStructureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSpatialZone(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZone', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSpatialZoneType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZoneType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSphere(*args, **kwargs): return ifcopenshell.create_entity('IfcSphere', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSphericalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSphericalSurface', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSpiral', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStackTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminal', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStackTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminalType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStair(*args, **kwargs): return ifcopenshell.create_entity('IfcStair', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStairFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlight', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStairFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlightType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStairType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAction', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralActivity', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralAnalysisModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAnalysisModel', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnection', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnectionCondition', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralCurveAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveAction', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralCurveConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveConnection', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralCurveMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMember', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralCurveMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMemberVarying', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralCurveReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveReaction', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralItem', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralLinearAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLinearAction', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralLoad(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoad', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralLoadCase(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadCase', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralLoadConfiguration(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadConfiguration', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralLoadGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadGroup', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralLoadLinearForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadLinearForce', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralLoadOrResult(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadOrResult', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralLoadPlanarForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadPlanarForce', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacement(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacementDistortion(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacementDistortion', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralLoadSingleForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForce', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralLoadSingleForceWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForceWarping', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralLoadStatic(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadStatic', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralLoadTemperature(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadTemperature', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralMember', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralPlanarAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPlanarAction', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralPointAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointAction', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralPointConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointConnection', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralPointReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointReaction', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralReaction', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralResultGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralResultGroup', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralSurfaceAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceAction', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralSurfaceConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceConnection', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralSurfaceMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMember', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralSurfaceMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMemberVarying', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStructuralSurfaceReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceReaction', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStyleModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStyleModel', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStyledItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledItem', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcStyledRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledRepresentation', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSubContractResource(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResource', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSubContractResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResourceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSubedge(*args, **kwargs): return ifcopenshell.create_entity('IfcSubedge', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSurface', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSurfaceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSurfaceCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurveSweptAreaSolid', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSurfaceFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceFeature', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSurfaceOfLinearExtrusion(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfLinearExtrusion', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSurfaceOfRevolution(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfRevolution', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSurfaceReinforcementArea(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceReinforcementArea', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyle', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSurfaceStyleLighting(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleLighting', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSurfaceStyleRefraction(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRefraction', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSurfaceStyleRendering(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRendering', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSurfaceStyleShading(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleShading', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSurfaceStyleWithTextures(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleWithTextures', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSurfaceTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceTexture', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptAreaSolid', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSweptDiskSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolid', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSweptDiskSolidPolygonal(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolidPolygonal', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSweptSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptSurface', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSwitchingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDevice', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSwitchingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDeviceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcSystem', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSystemFurnitureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcSystemFurnitureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTShapeProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTable(*args, **kwargs): return ifcopenshell.create_entity('IfcTable', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTableColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcTableColumn', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTableRow(*args, **kwargs): return ifcopenshell.create_entity('IfcTableRow', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTank(*args, **kwargs): return ifcopenshell.create_entity('IfcTank', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTankType(*args, **kwargs): return ifcopenshell.create_entity('IfcTankType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTask(*args, **kwargs): return ifcopenshell.create_entity('IfcTask', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTaskTime(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTime', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTaskTimeRecurring(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTimeRecurring', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTaskType(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTelecomAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcTelecomAddress', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTendon(*args, **kwargs): return ifcopenshell.create_entity('IfcTendon', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTendonAnchor(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchor', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTendonAnchorType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchorType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTendonConduit(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduit', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTendonConduitType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduitType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTendonType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTessellatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedFaceSet', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTessellatedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedItem', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTextLiteral(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteral', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTextLiteralWithExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteralWithExtent', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTextStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyle', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTextStyleFontModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleFontModel', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTextStyleForDefinedFont(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleForDefinedFont', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTextStyleTextModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleTextModel', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTextureCoordinate(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinate', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTextureCoordinateGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateGenerator', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTextureCoordinateIndices(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateIndices', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTextureCoordinateIndicesWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateIndicesWithVoids', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureMap', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTextureVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertex', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTextureVertexList(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertexList', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcThirdOrderPolynomialSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcThirdOrderPolynomialSpiral', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTimePeriod(*args, **kwargs): return ifcopenshell.create_entity('IfcTimePeriod', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeries', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeriesValue', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTopologicalRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologicalRepresentationItem', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTopologyRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologyRepresentation', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcToroidalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcToroidalSurface', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTrackElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTrackElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTrackElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTrackElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTransformer(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformer', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTransformerType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformerType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTransportElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTransportElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTransportationDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportationDevice', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTransportationDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportationDeviceType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTrapeziumProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTrapeziumProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTriangulatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedFaceSet', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTriangulatedIrregularNetwork(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedIrregularNetwork', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTrimmedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcTrimmedCurve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTubeBundle(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundle', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTubeBundleType(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundleType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTypeObject(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeObject', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTypeProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProcess', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTypeProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProduct', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcTypeResource(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeResource', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcUShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcUShapeProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcUnitAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitAssignment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcUnitaryControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcUnitaryControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElementType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcUnitaryEquipment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipment', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcUnitaryEquipmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipmentType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcValve(*args, **kwargs): return ifcopenshell.create_entity('IfcValve', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcValveType(*args, **kwargs): return ifcopenshell.create_entity('IfcValveType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcVector(*args, **kwargs): return ifcopenshell.create_entity('IfcVector', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcVehicle(*args, **kwargs): return ifcopenshell.create_entity('IfcVehicle', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcVehicleType(*args, **kwargs): return ifcopenshell.create_entity('IfcVehicleType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcVertex', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcVertexLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexLoop', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcVertexPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexPoint', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcVibrationDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamper', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcVibrationDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamperType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcVibrationIsolator(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolator', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcVibrationIsolatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolatorType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcVirtualElement(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualElement', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcVirtualGridIntersection(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualGridIntersection', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcVoidingFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcVoidingFeature', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcWall(*args, **kwargs): return ifcopenshell.create_entity('IfcWall', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcWallStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallStandardCase', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcWallType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcWasteTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminal', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcWasteTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminalType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcWellKnownText(*args, **kwargs): return ifcopenshell.create_entity('IfcWellKnownText', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcWindow(*args, **kwargs): return ifcopenshell.create_entity('IfcWindow', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcWindowLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowLiningProperties', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcWindowPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowPanelProperties', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcWindowType(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowType', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcWorkCalendar(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkCalendar', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcWorkControl(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkControl', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcWorkPlan(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkPlan', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcWorkSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkSchedule', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcWorkTime(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkTime', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcZShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcZShapeProfileDef', 'IFC4X3_ADD1', *args, **kwargs) + + +def IfcZone(*args, **kwargs): return ifcopenshell.create_entity('IfcZone', 'IFC4X3_ADD1', *args, **kwargs) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcBoxAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcBoxAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['top-left','top-middle','top-right','middle-left','center','middle-right','bottom-left','bottom-middle','bottom-right'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCardinalPointReference_GreaterThanZero: + SCOPE = "type" + TYPE_NAME = "IfcCardinalPointReference" + RULE_NAME = "GreaterThanZero" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCompoundPlaneAngleMeasure_MinutesInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MinutesInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[2 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_SecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "SecondsInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[3 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_MicrosecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MicrosecondsInRange" + + @staticmethod + def __call__(self): + + + assert (sizeof(self) == 3) or ((abs(self[4 - 1])) < 1000000) + + + + +class IfcCompoundPlaneAngleMeasure_ConsistentSign: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "ConsistentSign" + + @staticmethod + def __call__(self): + + + assert (((self[1 - 1]) >= 0) and ((self[2 - 1]) >= 0) and ((self[3 - 1]) >= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) >= 0))) or (((self[1 - 1]) <= 0) and ((self[2 - 1]) <= 0) and ((self[3 - 1]) <= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) <= 0))) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDayInMonthNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInMonthNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 31 + + + + + +class IfcDayInWeekNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInWeekNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 7 + + + + + + + + + + + + + + + + + +class IfcDimensionCount_WR1: + SCOPE = "type" + TYPE_NAME = "IfcDimensionCount" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0 < self <= 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFontStyle_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontStyle" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','italic','oblique'] + + + + + +class IfcFontVariant_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontVariant" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps'] + + + + + +class IfcFontWeight_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontWeight" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps','100','200','300','400','500','600','700','800','900'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcHeatingValueMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcHeatingValueMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMonthInYearNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcMonthInYearNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 12 + + + + + + + + + + + + + + +class IfcNonNegativeLengthMeasure_NotNegative: + SCOPE = "type" + TYPE_NAME = "IfcNonNegativeLengthMeasure" + RULE_NAME = "NotNegative" + + @staticmethod + def __call__(self): + + + assert self >= 0. + + + + + +class IfcNormalisedRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcNormalisedRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + +class IfcPHMeasure_WR21: + SCOPE = "type" + TYPE_NAME = "IfcPHMeasure" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 14.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPositiveInteger_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveInteger" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + +class IfcPositiveLengthMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveLengthMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositivePlaneAngleMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositivePlaneAngleMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositiveRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcSpecularRoughness_WR1: + SCOPE = "type" + TYPE_NAME = "IfcSpecularRoughness" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTextAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['left','right','center','justify'] + + + + + +class IfcTextDecoration_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextDecoration" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['none','underline','overline','line-through','blink'] + + + + + + + + + + + + + + +class IfcTextTransformation_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextTransformation" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['capitalize','uppercase','lowercase','none'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcActorRole_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcActorRole" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + role = self.Role + + assert (role != IfcRoleEnum.USERDEFINED) or ((role == IfcRoleEnum.USERDEFINED) and exists(self.UserDefinedRole)) + + + + + +class IfcActuator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcActuator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcactuatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcActuatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + purpose = self.Purpose + + assert (not exists(purpose)) or ((purpose != IfcAddressTypeEnum.USERDEFINED) or ((purpose == IfcAddressTypeEnum.USERDEFINED) and exists(self.UserDefinedPurpose))) + + + + + +class IfcAdvancedBrep_HasAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrep" + RULE_NAME = "HasAdvancedFaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([afs for afs in self.Outer.CfsFaces if not 'ifc4x3_add1.ifcadvancedface' in typeof(afs)])) == 0 + + + + + +class IfcAdvancedBrepWithVoids_VoidsHaveAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrepWithVoids" + RULE_NAME = "VoidsHaveAdvancedFaces" + + @staticmethod + def __call__(self): + voids = self.Voids + + assert (sizeof([vsh for vsh in voids if (sizeof([afs for afs in vsh.CfsFaces if not 'ifc4x3_add1.ifcadvancedface' in typeof(afs)])) == 0])) == 0 + + + + + +class IfcAdvancedFace_ApplicableEdgeCurves: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableEdgeCurves" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x3_add1.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not (sizeof(['ifc4x3_add1.ifcline','ifc4x3_add1.ifcconic','ifc4x3_add1.ifcpolyline','ifc4x3_add1.ifcbsplinecurve'] * typeof(oe.EdgeElement.EdgeGeometry))) == 1])) == 0])) == 0 + + + + +class IfcAdvancedFace_ApplicableSurface: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableSurface" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_add1.ifcelementarysurface','ifc4x3_add1.ifcsweptsurface','ifc4x3_add1.ifcbsplinesurface'] * typeof(self.FaceSurface))) == 1 + + + + +class IfcAdvancedFace_RequiresEdgeCurve: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "RequiresEdgeCurve" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x3_add1.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not 'ifc4x3_add1.ifcedgecurve' in typeof(oe.EdgeElement)])) == 0])) == 0 + + + + + +class IfcAirTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcairterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminalBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcairterminalboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirToAirHeatRecovery_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirToAirHeatRecovery_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcairtoairheatrecoverytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirToAirHeatRecoveryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecoveryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAlarm_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAlarm_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcalarmtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAlarmType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarmType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcApproval_HasIdentifierOrName: + SCOPE = "entity" + TYPE_NAME = "IfcApproval" + RULE_NAME = "HasIdentifierOrName" + + @staticmethod + def __call__(self): + identifier = self.Identifier + name = self.Name + + assert exists(identifier) or exists(name) + + + + + + + + +class IfcArbitraryClosedProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert outercurve.Dim == 2 + + + + +class IfcArbitraryClosedProfileDef_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x3_add1.ifcline' in typeof(outercurve) + + + + +class IfcArbitraryClosedProfileDef_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x3_add1.ifcoffsetcurve2d' in typeof(outercurve) + + + + + +class IfcArbitraryOpenProfileDef_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_add1.ifccenterlineprofiledef' in typeof(self)) or (self.ProfileType == IfcProfileTypeEnum.CURVE) + + + + +class IfcArbitraryOpenProfileDef_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + curve = self.Curve + + assert curve.Dim == 2 + + + + + +class IfcArbitraryProfileDefWithVoids_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == area + + + + +class IfcArbitraryProfileDefWithVoids_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if temp.Dim != 2])) == 0 + + + + +class IfcArbitraryProfileDefWithVoids_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if 'ifc4x3_add1.ifcline' in typeof(temp)])) == 0 + + + + + + + + +class IfcAsymmetricIShapeProfileDef_ValidBottomFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidBottomFilletRadius" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + bottomflangefilletradius = self.BottomFlangeFilletRadius + + assert (not exists(bottomflangefilletradius)) or (bottomflangefilletradius <= ((bottomflangewidth - webthickness) / 2.)) + + + + +class IfcAsymmetricIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + bottomflangethickness = self.BottomFlangeThickness + topflangethickness = self.TopFlangeThickness + + assert (not exists(topflangethickness)) or ((bottomflangethickness + topflangethickness) < overalldepth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidTopFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidTopFilletRadius" + + @staticmethod + def __call__(self): + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + topflangefilletradius = self.TopFlangeFilletRadius + + assert (not exists(topflangefilletradius)) or (topflangefilletradius <= ((topflangewidth - webthickness) / 2.)) + + + + +class IfcAsymmetricIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + + assert (webthickness < bottomflangewidth) and (webthickness < topflangewidth) + + + + + +class IfcAudioVisualAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAudioVisualAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcaudiovisualappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAudioVisualApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAxis1Placement_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis1Placement_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis1Placement_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_add1.ifccartesianpoint' in typeof(self.Location) + + + + +def calc_IfcAxis1Placement_Z(self): + axis = self.Axis + return \ + nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + + + + +class IfcAxis2Placement2D_LocationIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIs2D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 2 + + + + +class IfcAxis2Placement2D_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_add1.ifccartesianpoint' in typeof(self.Location) + + + + +class IfcAxis2Placement2D_RefDirIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "RefDirIs2D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 2) + + + + +def calc_IfcAxis2Placement2D_P(self): + refdirection = self.RefDirection + return \ + IfcBuild2Axes(refdirection) + + + + +class IfcAxis2Placement3D_AxisAndRefDirProvision: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisAndRefDirProvision" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert not exists(axis) ^ exists(refdirection) + + + + +class IfcAxis2Placement3D_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis2Placement3D_AxisToRefDirPosition: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisToRefDirPosition" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + +class IfcAxis2Placement3D_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis2Placement3D_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_add1.ifccartesianpoint' in typeof(self.Location) + + + + +class IfcAxis2Placement3D_RefDirIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "RefDirIs3D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 3) + + + + +def calc_IfcAxis2Placement3D_P(self): + axis = self.Axis + refdirection = self.RefDirection + return \ + IfcBuildAxes(axis,refdirection) + + + + +class IfcAxis2PlacementLinear_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2PlacementLinear" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_add1.ifcpointbydistanceexpression' in typeof(self.Location) + + + + +class IfcAxis2PlacementLinear_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2PlacementLinear" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + + +class IfcBSplineCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + controlpointslist = self.ControlPointsList + + assert (sizeof([temp for temp in controlpointslist if temp.Dim != (controlpointslist[1 - 1].Dim)])) == 0 + + + + +def calc_IfcBSplineCurve_UpperIndexOnControlPoints(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineCurve_ControlPoints(self): + controlpointslist = self.ControlPointsList + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + return \ + IfcListToArray(controlpointslist,0,upperindexoncontrolpoints) + + + + +class IfcBSplineCurveWithKnots_ConsistentBSpline: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "ConsistentBSpline" + + @staticmethod + def __call__(self): + degree = self.Degree + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + knotmultiplicities = self.KnotMultiplicities + knots = self.Knots + upperindexonknots = self.UpperIndexOnKnots + + assert IfcConstraintsParamBSpline(degree,upperindexonknots,upperindexoncontrolpoints,knotmultiplicities,knots) + + + + +class IfcBSplineCurveWithKnots_CorrespondingKnotLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "CorrespondingKnotLists" + + @staticmethod + def __call__(self): + knotmultiplicities = self.KnotMultiplicities + upperindexonknots = self.UpperIndexOnKnots + + assert sizeof(knotmultiplicities) == upperindexonknots + + + + +def calc_IfcBSplineCurveWithKnots_UpperIndexOnKnots(self): + knots = self.Knots + return \ + sizeof(knots) + + + + +def calc_IfcBSplineSurface_UUpper(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineSurface_VUpper(self): + controlpointslist = self.ControlPointsList + return \ + (sizeof(controlpointslist[1 - 1])) - 1 + + + +def calc_IfcBSplineSurface_ControlPoints(self): + controlpointslist = self.ControlPointsList + uupper = self.UUpper + vupper = self.VUpper + return \ + IfcMakeArrayOfArray(controlpointslist,0,uupper,0,vupper) + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingULists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingULists" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + knotuupper = self.KnotUUpper + + assert sizeof(umultiplicities) == knotuupper + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingVLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingVLists" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + knotvupper = self.KnotVUpper + + assert sizeof(vmultiplicities) == knotvupper + + + + +class IfcBSplineSurfaceWithKnots_UDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "UDirectionConstraints" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + uknots = self.UKnots + knotuupper = self.KnotUUpper + + assert IfcConstraintsParamBSpline(self.UDegree,knotuupper,self.UUpper,umultiplicities,uknots) + + + + +class IfcBSplineSurfaceWithKnots_VDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "VDirectionConstraints" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + vknots = self.VKnots + knotvupper = self.KnotVUpper + + assert IfcConstraintsParamBSpline(self.VDegree,knotvupper,self.VUpper,vmultiplicities,vknots) + + + + +def calc_IfcBSplineSurfaceWithKnots_KnotVUpper(self): + vknots = self.VKnots + return \ + sizeof(vknots) + + + +def calc_IfcBSplineSurfaceWithKnots_KnotUUpper(self): + uknots = self.UKnots + return \ + sizeof(uknots) + + + + +class IfcBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBearing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBearing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcbearingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBearingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBlobTexture_RasterCodeByteStream: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "RasterCodeByteStream" + + @staticmethod + def __call__(self): + rastercode = self.RasterCode + + assert (blength(rastercode) % 8) == 0 + + + + +class IfcBlobTexture_SupportedRasterFormat: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "SupportedRasterFormat" + + @staticmethod + def __call__(self): + + + assert self.RasterFormat in ['bmp','jpg','gif','png'] + + + + + + + + +class IfcBoiler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBoiler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcboilertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBoilerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoilerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBooleanClippingResult_FirstOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "FirstOperandType" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert ('ifc4x3_add1.ifcsweptareasolid' in typeof(firstoperand)) or ('ifc4x3_add1.ifcsweptdiscsolid' in typeof(firstoperand)) or ('ifc4x3_add1.ifcbooleanclippingresult' in typeof(firstoperand)) + + + + +class IfcBooleanClippingResult_OperatorType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "OperatorType" + + @staticmethod + def __call__(self): + operator = self.Operator + + assert operator == difference + + + + +class IfcBooleanClippingResult_SecondOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "SecondOperandType" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert 'ifc4x3_add1.ifchalfspacesolid' in typeof(secondoperand) + + + + + +class IfcBooleanResult_FirstOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "FirstOperandClosed" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert (not 'ifc4x3_add1.ifctessellatedfaceset' in typeof(firstoperand)) or (exists(firstoperand.Closed) and firstoperand.Closed) + + + + +class IfcBooleanResult_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + secondoperand = self.SecondOperand + + assert firstoperand.Dim == secondoperand.Dim + + + + +class IfcBooleanResult_SecondOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SecondOperandClosed" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert (not 'ifc4x3_add1.ifctessellatedfaceset' in typeof(secondoperand)) or (exists(secondoperand.Closed) and secondoperand.Closed) + + + + +def calc_IfcBooleanResult_Dim(self): + firstoperand = self.FirstOperand + return \ + firstoperand.Dim + + + + + + + + + + +class IfcBoundaryCurve_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBoundaryCurve" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + + + assert self.ClosedCurve + + + + + + + + + + + + + + + + + + + + + + + +def calc_IfcBoundingBox_Dim(self): + + return \ + 3 + + + + +class IfcBoxedHalfSpace_UnboundedSurface: + SCOPE = "entity" + TYPE_NAME = "IfcBoxedHalfSpace" + RULE_NAME = "UnboundedSurface" + + @staticmethod + def __call__(self): + + + assert not 'ifc4x3_add1.ifccurveboundedplane' in typeof(self.BaseSurface) + + + + + +class IfcBridge_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBridge" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBridgeTypeEnum.USERDEFINED) or ((predefinedtype == IfcBridgeTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcBridgePart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBridgePart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBridgePartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBridgePartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcBuildingElementPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementPart_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcbuildingelementparttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementPartType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPartType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBuildingElementProxy_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementProxy_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcbuildingelementproxytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + +class IfcBuildingElementProxy_HasObjectName: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "HasObjectName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcBuildingElementProxyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcBuildingSystem_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingSystem" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingSystemTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingSystemTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcBuiltElement_MaxOneMaterialAssociation: + SCOPE = "entity" + TYPE_NAME = "IfcBuiltElement" + RULE_NAME = "MaxOneMaterialAssociation" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.HasAssociations if 'ifc4x3_add1.ifcrelassociatesmaterial' in typeof(temp)])) <= 1 + + + + + + + + +class IfcBuiltSystem_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuiltSystem" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuiltSystemTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuiltSystemTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcBurner_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBurner_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcburnertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBurnerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurnerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCShapeProfileDef_ValidGirth: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidGirth" + + @staticmethod + def __call__(self): + depth = self.Depth + girth = self.Girth + + assert girth < (depth / 2.) + + + + +class IfcCShapeProfileDef_ValidInternalFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidInternalFilletRadius" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + internalfilletradius = self.InternalFilletRadius + + assert (not exists(internalfilletradius)) or ((internalfilletradius <= ((width / 2.) - wallthickness)) and (internalfilletradius <= ((depth / 2.) - wallthickness))) + + + + +class IfcCShapeProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + + assert (wallthickness < (width / 2.)) and (wallthickness < (depth / 2.)) + + + + + +class IfcCableCarrierFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccablecarrierfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableCarrierSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccablecarriersegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccablefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccablesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCaissonFoundation_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCaissonFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccaissonfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCaissonFoundationType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundationType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCartesianPoint_CP2Dor3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianPoint" + RULE_NAME = "CP2Dor3D" + + @staticmethod + def __call__(self): + coordinates = self.Coordinates + + assert hiindex(coordinates) >= 2 + + + + + +def calc_IfcCartesianPointList_Dim(self): + + return \ + IfcPointListDim(self) + + + + + + + + + + +class IfcCartesianTransformationOperator_ScaleGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator" + RULE_NAME = "ScaleGreaterZero" + + @staticmethod + def __call__(self): + scl = self.Scl + + assert scl > 0.0 + + + + +def calc_IfcCartesianTransformationOperator_Scl(self): + scale = self.Scale + return \ + nvl(scale,1.0) + + + +def calc_IfcCartesianTransformationOperator_Dim(self): + localorigin = self.LocalOrigin + return \ + localorigin.Dim + + + + +class IfcCartesianTransformationOperator2D_Axis1Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis1Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 2) + + + + +class IfcCartesianTransformationOperator2D_Axis2Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis2Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 2) + + + + +class IfcCartesianTransformationOperator2D_DimEqual2: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "DimEqual2" + + @staticmethod + def __call__(self): + + + assert self.Dim == 2 + + + + +def calc_IfcCartesianTransformationOperator2D_U(self): + + return \ + IfcBaseAxis(2,self.Axis1,self.Axis2,None) + + + + +class IfcCartesianTransformationOperator2DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator2DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + + +class IfcCartesianTransformationOperator3D_Axis1Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis1Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis2Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis2Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis3Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis3Is3D" + + @staticmethod + def __call__(self): + axis3 = self.Axis3 + + assert (not exists(axis3)) or (axis3.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_DimIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "DimIs3D" + + @staticmethod + def __call__(self): + + + assert self.Dim == 3 + + + + +def calc_IfcCartesianTransformationOperator3D_U(self): + axis3 = self.Axis3 + return \ + IfcBaseAxis(3,self.Axis1,self.Axis2,axis3) + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale3GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale3GreaterZero" + + @staticmethod + def __call__(self): + scl3 = self.Scl3 + + assert scl3 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl3(self): + scale3 = self.Scale3 + return \ + nvl(scale3,self.Scl) + + + + + + + +class IfcChiller_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChiller_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcchillertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChillerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChillerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcChimney_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChimney_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcchimneytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChimneyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimneyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcCircleHollowProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCircleHollowProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert wallthickness < self.Radius + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoil_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccoiltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoilType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoilType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcColumn_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcColumn_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccolumntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcColumnType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumnType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcComplexProperty_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert (sizeof([temp for temp in hasproperties if self == temp])) == 0 + + + + +class IfcComplexProperty_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + +class IfcComplexPropertyTemplate_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert (sizeof([temp for temp in haspropertytemplates if self == temp])) == 0 + + + + +class IfcComplexPropertyTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + + +class IfcCompositeCurve_CurveContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "CurveContinuous" + + @staticmethod + def __call__(self): + segments = self.Segments + closedcurve = self.ClosedCurve + + assert ((not closedcurve) and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 1)) or (closedcurve and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 0)) + + + + +class IfcCompositeCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (sizeof([temp for temp in segments if temp.Dim != (segments[1 - 1].Dim)])) == 0 + + + + +def calc_IfcCompositeCurve_NSegments(self): + segments = self.Segments + return \ + sizeof(segments) + + + +def calc_IfcCompositeCurve_ClosedCurve(self): + segments = self.Segments + nsegments = self.NSegments + return \ + (segments[nsegments - 1].Transition) != discontinuous + + + + +class IfcCompositeCurveOnSurface_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveOnSurface" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + + assert sizeof(basissurface) > 0 + + + + +def calc_IfcCompositeCurveOnSurface_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + +class IfcCompositeCurveSegment_ParentIsBoundedCurve: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveSegment" + RULE_NAME = "ParentIsBoundedCurve" + + @staticmethod + def __call__(self): + parentcurve = self.ParentCurve + + assert 'ifc4x3_add1.ifcboundedcurve' in typeof(parentcurve) + + + + + +class IfcCompositeProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if temp.ProfileType != (profiles[1 - 1].ProfileType)])) == 0 + + + + +class IfcCompositeProfileDef_NoRecursion: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "NoRecursion" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if 'ifc4x3_add1.ifccompositeprofiledef' in typeof(temp)])) == 0 + + + + + +class IfcCompressor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCompressor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccompressortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCompressorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCondenser_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCondenser_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccondensertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCondenserType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenserType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcConstraint_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcConstraint" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + constraintgrade = self.ConstraintGrade + + assert (constraintgrade != IfcConstraintEnum.USERDEFINED) or ((constraintgrade == IfcConstraintEnum.USERDEFINED) and exists(self.UserDefinedGrade)) + + + + + +class IfcConstructionEquipmentResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionEquipmentResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionMaterialResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionMaterialResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionProductResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionProductResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + + + + + + + + + + + + + +class IfcController_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcController_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccontrollertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcControllerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcControllerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcConveyorSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConveyorSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcConveyorSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcConveyorSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcconveyorsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcConveyorSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConveyorSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcConveyorSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCooledBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCooledBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccooledbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCooledBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCoolingTower_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoolingTower_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccoolingtowertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoolingTowerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTowerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcCoordinateReferenceSystem_NameOrWKT: + SCOPE = "entity" + TYPE_NAME = "IfcCoordinateReferenceSystem" + RULE_NAME = "NameOrWKT" + + @staticmethod + def __call__(self): + name = self.Name + wellknowntext = self.WellKnownText + + assert (hiindex(wellknowntext) == 1) or exists(name) + + + + + + + + + + + + + + + + + +class IfcCourse_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCourse" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCourseTypeEnum.USERDEFINED) or ((predefinedtype == IfcCourseTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCourse_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCourse" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccoursetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCourseType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCourseType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCourseTypeEnum.USERDEFINED) or ((predefinedtype == IfcCourseTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCovering_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCovering_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccoveringtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoveringType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoveringType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCrewResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcCrewResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +def calc_IfcCsgPrimitive3D_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcCurtainWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCurtainWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifccurtainwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCurtainWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcCurve_Dim(self): + + return \ + IfcCurveDim(self) + + + + + + + + + + + + + +class IfcCurveStyle_IdentifiableCurveStyle: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "IdentifiableCurveStyle" + + @staticmethod + def __call__(self): + curvefont = self.CurveFont + curvewidth = self.CurveWidth + curvecolour = self.CurveColour + + assert exists(curvefont) or exists(curvewidth) or exists(curvecolour) + + + + +class IfcCurveStyle_MeasureOfWidth: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "MeasureOfWidth" + + @staticmethod + def __call__(self): + curvewidth = self.CurveWidth + + assert (not exists(curvewidth)) or ('ifc4x3_add1.ifcpositivelengthmeasure' in typeof(curvewidth)) or (('ifc4x3_add1.ifcdescriptivemeasure' in typeof(curvewidth)) and (curvewidth == 'bylayer')) + + + + + + + + + + + +class IfcCurveStyleFontPattern_VisibleLengthGreaterEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyleFontPattern" + RULE_NAME = "VisibleLengthGreaterEqualZero" + + @staticmethod + def __call__(self): + visiblesegmentlength = self.VisibleSegmentLength + + assert visiblesegmentlength >= 0. + + + + + + + + +class IfcDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDeepFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDeepFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcdeepfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + + + + +class IfcDerivedProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + parentprofile = self.ParentProfile + + assert self.ProfileType == parentprofile.ProfileType + + + + + +class IfcDerivedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof(elements) > 1) or ((sizeof(elements) == 1) and ((elements[1 - 1].Exponent) != 1)) + + + + +class IfcDerivedUnit_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + unittype = self.UnitType + + assert (unittype != IfcDerivedUnitEnum.USERDEFINED) or ((unittype == IfcDerivedUnitEnum.USERDEFINED) and exists(self.UserDefinedType)) + + + + +def calc_IfcDerivedUnit_Dimensions(self): + elements = self.Elements + return \ + IfcDeriveDimensionalExponents(elements) + + + + + + + + + + +class IfcDirection_MagnitudeGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcDirection" + RULE_NAME = "MagnitudeGreaterZero" + + @staticmethod + def __call__(self): + directionratios = self.DirectionRatios + + assert (sizeof([tmp for tmp in directionratios if tmp != 0.0])) > 0 + + + + +def calc_IfcDirection_Dim(self): + directionratios = self.DirectionRatios + return \ + hiindex(directionratios) + + + + +class IfcDirectrixCurveSweptAreaSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcDirectrixCurveSweptAreaSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x3_add1.ifcconic','ifc4x3_add1.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + + + + +class IfcDiscreteAccessory_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDiscreteAccessory_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcdiscreteaccessorytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDiscreteAccessoryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessoryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDistributionChamberElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionChamberElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcdistributionchamberelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionChamberElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDistributionSystem_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionSystem" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionSystemEnum.USERDEFINED) or ((predefinedtype == IfcDistributionSystemEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcDocumentReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDocumentReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + name = self.Name + referenceddocument = self.ReferencedDocument + + assert exists(name) ^ exists(referenceddocument) + + + + + +class IfcDoor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDoorTypeEnum.USERDEFINED) or ((predefinedtype == IfcDoorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDoor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcdoortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDoorLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcDoorLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + thresholddepth = self.ThresholdDepth + thresholdthickness = self.ThresholdThickness + + assert not exists(thresholddepth) and (not exists(thresholdthickness)) + + + + +class IfcDoorLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + transomthickness = self.TransomThickness + transomoffset = self.TransomOffset + + assert (exists(transomoffset) and exists(transomthickness)) ^ ((not exists(transomoffset)) and (not exists(transomthickness))) + + + + +class IfcDoorLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + casingthickness = self.CasingThickness + casingdepth = self.CasingDepth + + assert (exists(casingdepth) and exists(casingthickness)) ^ ((not exists(casingdepth)) and (not exists(casingthickness))) + + + + +class IfcDoorLiningProperties_WR35: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR35" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and ('ifc4x3_add1.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) + + + + + +class IfcDoorPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and ('ifc4x3_add1.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) + + + + + +class IfcDoorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDoorTypeEnum.USERDEFINED) or ((predefinedtype == IfcDoorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDraughtingPreDefinedColour_PreDefinedColourNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedColour" + RULE_NAME = "PreDefinedColourNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['black','red','green','blue','yellow','magenta','cyan','white','bylayer'] + + + + + +class IfcDraughtingPreDefinedCurveFont_PreDefinedCurveFontNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedCurveFont" + RULE_NAME = "PreDefinedCurveFontNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['continuous','chain','chaindoubledash','dashed','dotted','bylayer'] + + + + + +class IfcDuctFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcductfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcductsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSilencer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSilencer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcductsilencertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSilencerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEarthworksCut_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEarthworksCut" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEarthworksCutTypeEnum.USERDEFINED) or ((predefinedtype == IfcEarthworksCutTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcEarthworksFill_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEarthworksFill" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEarthworksFillTypeEnum.USERDEFINED) or ((predefinedtype == IfcEarthworksFillTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcEdgeLoop_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + edgelist = self.EdgeList + ne = self.Ne + + assert (edgelist[1 - 1].EdgeStart) == (edgelist[ne - 1].EdgeEnd) + + + + +class IfcEdgeLoop_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcLoopHeadToTail(self) + + + + +def calc_IfcEdgeLoop_Ne(self): + edgelist = self.EdgeList + return \ + sizeof(edgelist) + + + + +class IfcElectricAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcelectricappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcelectricdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowStorageDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowStorageDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcelectricflowstoragedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowStorageDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowTreatmentDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowTreatmentDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcelectricflowtreatmentdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowTreatmentDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricGenerator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricGenerator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcelectricgeneratortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricGeneratorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGeneratorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricMotor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricMotor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcelectricmotortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricMotorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricTimeControl_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricTimeControl_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcelectrictimecontroltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricTimeControlType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControlType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcElementAssembly_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElementAssembly_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcelementassemblytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElementAssemblyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssemblyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcElementQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcElementQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + quantities = self.Quantities + + assert IfcUniqueQuantityNames(quantities) + + + + + + + + + + + + + + + + + + + + + + + +class IfcEngine_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEngine_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcenginetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEngineType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngineType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporativeCooler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporativeCooler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcevaporativecoolertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporativeCoolerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCoolerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcevaporatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvent_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvent_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (not exists(eventtriggertype)) or (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + +class IfcEventType_CorrectEventTriggerType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectEventTriggerType" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + +class IfcEventType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + + + + + + + +class IfcExternalReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcExternalReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + location = self.Location + identification = self.Identification + name = self.Name + + assert exists(identification) or exists(location) or exists(name) + + + + + + + + + + + + + + + + + + + + + + + +class IfcExtrudedAreaSolid_ValidExtrusionDirection: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolid" + RULE_NAME = "ValidExtrusionDirection" + + @staticmethod + def __call__(self): + + + assert IfcDotProduct(IfcDirection(DirectionRatios=[0.0,0.0,1.0]),self.ExtrudedDirection) != 0.0 + + + + + +class IfcExtrudedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + +class IfcFace_HasOuterBound: + SCOPE = "entity" + TYPE_NAME = "IfcFace" + RULE_NAME = "HasOuterBound" + + @staticmethod + def __call__(self): + bounds = self.Bounds + + assert (sizeof([temp for temp in bounds if 'ifc4x3_add1.ifcfaceouterbound' in typeof(temp)])) <= 1 + + + + + +def calc_IfcFaceBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFacilityPartCommon_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFacilityPartCommon" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFacilityPartCommonTypeEnum.USERDEFINED) or ((predefinedtype == IfcFacilityPartCommonTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcFan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFan_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcfantype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFanType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFanType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFeatureElement_NotContained: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElement" + RULE_NAME = "NotContained" + + @staticmethod + def __call__(self): + containedinstructure = self.ContainedInStructure + + assert sizeof(containedinstructure) == 0 + + + + + + + + +class IfcFeatureElementSubtraction_HasNoSubtraction: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "HasNoSubtraction" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasOpenings) == 0 + + + + +class IfcFeatureElementSubtraction_IsNotFilling: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "IsNotFilling" + + @staticmethod + def __call__(self): + + + assert sizeof(self.FillsVoids) == 0 + + + + + +class IfcFillAreaStyle_ConsistentHatchStyleDef: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "ConsistentHatchStyleDef" + + @staticmethod + def __call__(self): + + + assert IfcCorrectFillAreaStyle(self.FillStyles) + + + + +class IfcFillAreaStyle_MaxOneColour: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneColour" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x3_add1.ifccolour' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_MaxOneExtHatchStyle: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneExtHatchStyle" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x3_add1.ifcexternallydefinedhatchstyle' in typeof(style)])) <= 1 + + + + + +class IfcFillAreaStyleHatching_PatternStart2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "PatternStart2D" + + @staticmethod + def __call__(self): + patternstart = self.PatternStart + + assert (not exists(patternstart)) or (patternstart.Dim == 2) + + + + +class IfcFillAreaStyleHatching_RefHatchLine2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "RefHatchLine2D" + + @staticmethod + def __call__(self): + pointofreferencehatchline = self.PointOfReferenceHatchLine + + assert (not exists(pointofreferencehatchline)) or (pointofreferencehatchline.Dim == 2) + + + + + + + + +class IfcFilter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFilter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcfiltertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFilterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFireSuppressionTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFireSuppressionTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcfiresuppressionterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFireSuppressionTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + +class IfcFlowInstrument_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowInstrument_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcflowinstrumenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowInstrumentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrumentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFlowMeter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowMeter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcflowmetertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowMeterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFooting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFooting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcfootingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFootingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFootingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcFurniture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFurniture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcfurnituretype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFurnitureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurnitureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeographicCRS_IsPlaneAngleUnit: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicCRS" + RULE_NAME = "IsPlaneAngleUnit" + + @staticmethod + def __call__(self): + unit = self.Unit + + assert (not exists(unit)) or (unit.UnitType == IfcUnitEnum.PLANEANGLEUNIT) + + + + + +class IfcGeographicElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcGeographicElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcgeographicelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcGeographicElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeometricCurveSet_NoSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricCurveSet" + RULE_NAME = "NoSurfaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Elements if 'ifc4x3_add1.ifcsurface' in typeof(temp)])) == 0 + + + + + +class IfcGeometricRepresentationContext_North2D: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationContext" + RULE_NAME = "North2D" + + @staticmethod + def __call__(self): + truenorth = self.TrueNorth + + assert (not exists(truenorth)) or (hiindex(truenorth.DirectionRatios) == 2) + + + + + + + + +class IfcGeometricRepresentationSubContext_NoCoordOperation: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "NoCoordOperation" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasCoordinateOperation) == 0 + + + + +class IfcGeometricRepresentationSubContext_ParentNoSub: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "ParentNoSub" + + @staticmethod + def __call__(self): + parentcontext = self.ParentContext + + assert not 'ifc4x3_add1.ifcgeometricrepresentationsubcontext' in typeof(parentcontext) + + + + +class IfcGeometricRepresentationSubContext_UserTargetProvided: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "UserTargetProvided" + + @staticmethod + def __call__(self): + targetview = self.TargetView + userdefinedtargetview = self.UserDefinedTargetView + + assert (targetview != IfcGeometricProjectionEnum.USERDEFINED) or ((targetview == IfcGeometricProjectionEnum.USERDEFINED) and exists(userdefinedtargetview)) + + + + +def calc_IfcGeometricRepresentationSubContext_WorldCoordinateSystem(self): + parentcontext = self.ParentContext + return \ + parentcontext.WorldCoordinateSystem + + + +def calc_IfcGeometricRepresentationSubContext_CoordinateSpaceDimension(self): + parentcontext = self.ParentContext + return \ + parentcontext.CoordinateSpaceDimension + + + +def calc_IfcGeometricRepresentationSubContext_TrueNorth(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.TrueNorth,IfcConvertDirectionInto2D(self.WorldCoordinateSystem.P[2 - 1])) + + + +def calc_IfcGeometricRepresentationSubContext_Precision(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.Precision,1) + + + + +class IfcGeometricSet_ConsistentDim: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricSet" + RULE_NAME = "ConsistentDim" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof([temp for temp in elements if temp.Dim != (elements[1 - 1].Dim)])) == 0 + + + + +def calc_IfcGeometricSet_Dim(self): + elements = self.Elements + return \ + elements[1 - 1].Dim + + + + + + + + + + + + + + + + +class IfcGeotechnicalStratum_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeotechnicalStratum" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcGeotechnicalStratumTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeotechnicalStratumTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcGridAxis_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + axiscurve = self.AxisCurve + + assert axiscurve.Dim == 2 + + + + +class IfcGridAxis_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + partofw = self.PartOfW + partofv = self.PartOfV + partofu = self.PartOfU + + assert (sizeof(partofu) == 1) ^ (sizeof(partofv) == 1) ^ (sizeof(partofw) == 1) + + + + + + + + + + + +def calc_IfcHalfSpaceSolid_Dim(self): + + return \ + 3 + + + + +class IfcHeatExchanger_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHeatExchanger_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcheatexchangertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHeatExchangerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchangerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcHumidifier_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHumidifier_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifchumidifiertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHumidifierType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifierType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIShapeProfileDef_ValidFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFilletRadius" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + overalldepth = self.OverallDepth + webthickness = self.WebThickness + flangethickness = self.FlangeThickness + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or ((filletradius <= ((overallwidth - webthickness) / 2.)) and (filletradius <= ((overalldepth - (2. * flangethickness)) / 2.))) + + + + +class IfcIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + flangethickness = self.FlangeThickness + + assert (2. * flangethickness) < overalldepth + + + + +class IfcIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + webthickness = self.WebThickness + + assert webthickness < overallwidth + + + + + + + + +class IfcImpactProtectionDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcImpactProtectionDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcImpactProtectionDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcimpactprotectiondevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcImpactProtectionDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcImpactProtectionDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcIndexedPolyCurve_Consecutive: + SCOPE = "entity" + TYPE_NAME = "IfcIndexedPolyCurve" + RULE_NAME = "Consecutive" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (not exists(segments)) or IfcConsecutiveSegments(segments) + + + + + + + + + + + + + + + + + + + + +class IfcInterceptor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcInterceptor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcinterceptortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcInterceptorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIntersectionCurve_DistinctSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "DistinctSurfaces" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) != (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + +class IfcIntersectionCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + + + + + + + + + + + +class IfcJunctionBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcJunctionBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcjunctionboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcJunctionBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcKerb_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcKerb" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcKerbTypeEnum.USERDEFINED) or ((predefinedtype == IfcKerbTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcKerb_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcKerb" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifckerbtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcKerbType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcKerbType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcKerbTypeEnum.USERDEFINED) or ((predefinedtype == IfcKerbTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcLShapeProfileDef_ValidThickness: + SCOPE = "entity" + TYPE_NAME = "IfcLShapeProfileDef" + RULE_NAME = "ValidThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + thickness = self.Thickness + + assert (thickness < depth) and ((not exists(width)) or (thickness < width)) + + + + + +class IfcLaborResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcLaborResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +class IfcLamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifclamptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcLightFixture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLightFixture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifclightfixturetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLightFixtureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixtureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcLine_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcLine" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + pnt = self.Pnt + dir = self.Dir + + assert dir.Dim == pnt.Dim + + + + + + + + + + + + + + +class IfcLiquidTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLiquidTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcLiquidTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLiquidTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcliquidterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLiquidTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLiquidTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcLiquidTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcLocalPlacement_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcLocalPlacement" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + placementrelto = self.PlacementRelTo + relativeplacement = self.RelativePlacement + + assert IfcCorrectLocalPlacement(relativeplacement,placementrelto) + + + + + + + + + + + + + + + + + + + + +class IfcMarineFacility_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMarineFacility" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMarineFacilityTypeEnum.USERDEFINED) or ((predefinedtype == IfcMarineFacilityTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcMarinePart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMarinePart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMarinePartTypeEnum.USERDEFINED) or ((predefinedtype == IfcMarinePartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + + + + + + + + + + +class IfcMaterialDefinitionRepresentation_OnlyStyledRepresentations: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialDefinitionRepresentation" + RULE_NAME = "OnlyStyledRepresentations" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x3_add1.ifcstyledrepresentation' in typeof(temp)])) == 0 + + + + + +class IfcMaterialLayer_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialLayer" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + +def calc_IfcMaterialLayerSet_TotalThickness(self): + + return \ + IfcMlsTotalThickness(self) + + + + + + + + + + + + + +class IfcMaterialProfile_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialProfile" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMechanicalFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMechanicalFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcmechanicalfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMechanicalFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMedicalDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMedicalDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcmedicaldevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMedicalDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMember_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMember_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcmembertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMemberType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMemberType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcMirroredProfileDef_Operator(self): + + return \ + IfcCartesianTransformationOperator2D(Axis1=IfcDirection(DirectionRatios=[-1.,0.]), Axis2=IfcDirection(DirectionRatios=[0.,1.]), LocalOrigin=IfcCartesianPoint(Coordinates=[0.,0.]), Scale=1.) + + + + +class IfcMobileTelecommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMobileTelecommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcmobiletelecommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMobileTelecommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcMooringDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMooringDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMooringDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMooringDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcmooringdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMooringDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMooringDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMooringDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMotorConnection_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMotorConnection_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcmotorconnectiontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMotorConnectionType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnectionType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcNamedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcNamedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert IfcCorrectDimensions(self.UnitType,self.Dimensions) + + + + + +class IfcNavigationElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcNavigationElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcNavigationElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcNavigationElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcnavigationelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcNavigationElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcNavigationElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcNavigationElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + isdefinedby = self.IsDefinedBy + + assert (sizeof(isdefinedby) == 0) or IfcUniqueDefinitionNames(isdefinedby) + + + + + + + + + + + +class IfcObjective_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcObjective" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + objectivequalifier = self.ObjectiveQualifier + + assert (objectivequalifier != IfcObjectiveEnum.USERDEFINED) or ((objectivequalifier == IfcObjectiveEnum.USERDEFINED) and exists(self.UserDefinedQualifier)) + + + + + +class IfcOccupant_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcOccupant" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not predefinedtype == IfcOccupantTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcOffsetCurve2D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve2D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 2 + + + + + +class IfcOffsetCurve3D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve3D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 3 + + + + + + + + +class IfcOpenCrossProfileDef_CorrectProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrectProfileType" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == IfcProfileTypeEnum.CURVE + + + + +class IfcOpenCrossProfileDef_CorrespondingSlopeWidths: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrespondingSlopeWidths" + + @staticmethod + def __call__(self): + widths = self.Widths + slopes = self.Slopes + + assert sizeof(slopes) == sizeof(widths) + + + + +class IfcOpenCrossProfileDef_CorrespondingTags: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrespondingTags" + + @staticmethod + def __call__(self): + slopes = self.Slopes + tags = self.Tags + + assert (not exists(tags)) or (sizeof(tags) == (sizeof(slopes) + 1)) + + + + + + + + +class IfcOpeningElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOpeningElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcOpeningElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcOpeningElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcOrientedEdge_EdgeElementNotOriented: + SCOPE = "entity" + TYPE_NAME = "IfcOrientedEdge" + RULE_NAME = "EdgeElementNotOriented" + + @staticmethod + def __call__(self): + edgeelement = self.EdgeElement + + assert not 'ifc4x3_add1.ifcorientededge' in typeof(edgeelement) + + + + +def calc_IfcOrientedEdge_EdgeStart(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeStart,edgeelement.EdgeEnd) + + + +def calc_IfcOrientedEdge_EdgeEnd(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeEnd,edgeelement.EdgeStart) + + + + + + + +class IfcOutlet_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcOutlet_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcoutlettype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcOutletType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutletType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcOwnerHistory_CorrectChangeAction: + SCOPE = "entity" + TYPE_NAME = "IfcOwnerHistory" + RULE_NAME = "CorrectChangeAction" + + @staticmethod + def __call__(self): + changeaction = self.ChangeAction + lastmodifieddate = self.LastModifiedDate + + assert exists(lastmodifieddate) or ((not exists(lastmodifieddate)) and (not exists(changeaction))) or ((not exists(lastmodifieddate)) and exists(changeaction) and ((changeaction == IfcChangeActionEnum.NOTDEFINED) or (changeaction == IfcChangeActionEnum.NOCHANGE))) + + + + + + + + +class IfcPath_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcPath" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcPathHeadToTail(self) + + + + + +class IfcPavement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPavement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPavementTypeEnum.USERDEFINED) or ((predefinedtype == IfcPavementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPavement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPavement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcpavementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPavementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPavementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPavementTypeEnum.USERDEFINED) or ((predefinedtype == IfcPavementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPcurve_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcPcurve" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + referencecurve = self.ReferenceCurve + + assert referencecurve.Dim == 2 + + + + + + + + + + + + + + +class IfcPerson_IdentifiablePerson: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "IdentifiablePerson" + + @staticmethod + def __call__(self): + identification = self.Identification + familyname = self.FamilyName + givenname = self.GivenName + + assert exists(identification) or exists(familyname) or exists(givenname) + + + + +class IfcPerson_ValidSetOfNames: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "ValidSetOfNames" + + @staticmethod + def __call__(self): + familyname = self.FamilyName + givenname = self.GivenName + middlenames = self.MiddleNames + + assert (not exists(middlenames)) or exists(familyname) or exists(givenname) + + + + + + + + +class IfcPhysicalComplexQuantity_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert (sizeof([temp for temp in hasquantities if self == temp])) == 0 + + + + +class IfcPhysicalComplexQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert IfcUniqueQuantityNames(hasquantities) + + + + + + + + + + + +class IfcPile_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPile_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcpiletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPileType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPileType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcpipefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcpipesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPixelTexture_MinPixelInS: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInS" + + @staticmethod + def __call__(self): + width = self.Width + + assert width >= 1 + + + + +class IfcPixelTexture_MinPixelInT: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInT" + + @staticmethod + def __call__(self): + height = self.Height + + assert height >= 1 + + + + +class IfcPixelTexture_NumberOfColours: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "NumberOfColours" + + @staticmethod + def __call__(self): + colourcomponents = self.ColourComponents + + assert 1 <= colourcomponents <= 4 + + + + +class IfcPixelTexture_PixelAsByteAndSameLength: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "PixelAsByteAndSameLength" + + @staticmethod + def __call__(self): + pixel = self.Pixel + + assert (sizeof([temp for temp in pixel if ((blength(temp) % 8) == 0) and (blength(temp) == (blength(pixel[1 - 1])))])) == sizeof(pixel) + + + + +class IfcPixelTexture_SizeOfPixelList: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "SizeOfPixelList" + + @staticmethod + def __call__(self): + width = self.Width + height = self.Height + pixel = self.Pixel + + assert sizeof(pixel) == (width * height) + + + + + +def calc_IfcPlacement_Dim(self): + location = self.Location + return \ + location.Dim + + + + + + + + + + + + + +class IfcPlate_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPlate_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcplatetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPlateType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlateType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcPoint_Dim(self): + + return \ + IfcPointDim(self) + + + + + + + + + + + + + +class IfcPolyLoop_AllPointsSameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyLoop" + RULE_NAME = "AllPointsSameDim" + + @staticmethod + def __call__(self): + polygon = self.Polygon + + assert (sizeof([temp for temp in polygon if temp.Dim != (polygon[1 - 1].Dim)])) == 0 + + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryDim" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert polygonalboundary.Dim == 2 + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryType: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryType" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert (sizeof(typeof(polygonalboundary) * ['ifc4x3_add1.ifcpolyline','ifc4x3_add1.ifccompositecurve','ifc4x3_add1.ifcindexedpolycurve'])) == 1 + + + + + + + + +class IfcPolyline_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyline" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + points = self.Points + + assert (sizeof([temp for temp in points if temp.Dim != (points[1 - 1].Dim)])) == 0 + + + + + +class IfcPolynomialCurve_CorrectPositionDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolynomialCurve" + RULE_NAME = "CorrectPositionDim" + + @staticmethod + def __call__(self): + position = self.Position + coefficientsz = self.CoefficientsZ + + assert ((position.Dim == 2) and (not exists(coefficientsz))) or (position.Dim == 3) + + + + +class IfcPolynomialCurve_ValidCoefficients: + SCOPE = "entity" + TYPE_NAME = "IfcPolynomialCurve" + RULE_NAME = "ValidCoefficients" + + @staticmethod + def __call__(self): + coefficientsx = self.CoefficientsX + coefficientsy = self.CoefficientsY + coefficientsz = self.CoefficientsZ + + assert (exists(coefficientsx) and exists(coefficientsy)) or (exists(coefficientsx) and exists(coefficientsz)) or (exists(coefficientsy) and exists(coefficientsz)) or (exists(coefficientsx) and exists(coefficientsy) and exists(coefficientsz)) + + + + + + + + +class IfcPositioningElement_HasPlacement: + SCOPE = "entity" + TYPE_NAME = "IfcPositioningElement" + RULE_NAME = "HasPlacement" + + @staticmethod + def __call__(self): + + + assert exists(self.ObjectPlacement) + + + + + +class IfcPostalAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPostalAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + internallocation = self.InternalLocation + addresslines = self.AddressLines + postalbox = self.PostalBox + town = self.Town + region = self.Region + postalcode = self.PostalCode + country = self.Country + + assert exists(internallocation) or exists(addresslines) or exists(postalbox) or exists(postalcode) or exists(town) or exists(region) or exists(country) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPresentationLayerAssignment_ApplicableItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerAssignment" + RULE_NAME = "ApplicableItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x3_add1.ifcshaperepresentation','ifc4x3_add1.ifcgeometricrepresentationitem','ifc4x3_add1.ifcmappeditem'])) == 1])) == sizeof(assigneditems) + + + + + +class IfcPresentationLayerWithStyle_ApplicableOnlyToItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerWithStyle" + RULE_NAME = "ApplicableOnlyToItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x3_add1.ifcgeometricrepresentationitem','ifc4x3_add1.ifcmappeditem'])) >= 1])) == sizeof(assigneditems) + + + + + + + + +class IfcProcedure_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProcedure_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcProcedureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + + + + +class IfcProduct_PlacementForShapeRepresentation: + SCOPE = "entity" + TYPE_NAME = "IfcProduct" + RULE_NAME = "PlacementForShapeRepresentation" + + @staticmethod + def __call__(self): + objectplacement = self.ObjectPlacement + representation = self.Representation + + assert (exists(representation) and exists(objectplacement)) or (exists(representation) and ((sizeof([temp for temp in representation.Representations if 'ifc4x3_add1.ifcshaperepresentation' in typeof(temp)])) == 0)) or (not exists(representation)) + + + + + +class IfcProductDefinitionShape_OnlyShapeModel: + SCOPE = "entity" + TYPE_NAME = "IfcProductDefinitionShape" + RULE_NAME = "OnlyShapeModel" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x3_add1.ifcshapemodel' in typeof(temp)])) == 0 + + + + + + + + + + + + + + +class IfcProject_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert (not exists(self.RepresentationContexts)) or ((sizeof([temp for temp in self.RepresentationContexts if 'ifc4x3_add1.ifcgeometricrepresentationsubcontext' in typeof(temp)])) == 0) + + + + +class IfcProject_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProject_NoDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "NoDecomposition" + + @staticmethod + def __call__(self): + + + assert sizeof(self.Decomposes) == 0 + + + + + + + + + + + +class IfcProjectedCRS_IsLengthUnit: + SCOPE = "entity" + TYPE_NAME = "IfcProjectedCRS" + RULE_NAME = "IsLengthUnit" + + @staticmethod + def __call__(self): + mapunit = self.MapUnit + + assert (not exists(mapunit)) or (mapunit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + + +class IfcProjectionElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProjectionElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProjectionElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcProjectionElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcPropertyBoundedValue_SameUnitLowerSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitLowerSet" + + @staticmethod + def __call__(self): + lowerboundvalue = self.LowerBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(lowerboundvalue)) or (not exists(setpointvalue)) or (typeof(lowerboundvalue) == typeof(setpointvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitUpperLower: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperLower" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + lowerboundvalue = self.LowerBoundValue + + assert (not exists(upperboundvalue)) or (not exists(lowerboundvalue)) or (typeof(upperboundvalue) == typeof(lowerboundvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitUpperSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperSet" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(upperboundvalue)) or (not exists(setpointvalue)) or (typeof(upperboundvalue) == typeof(setpointvalue)) + + + + + + + + +class IfcPropertyDependencyRelationship_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyDependencyRelationship" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + dependingproperty = self.DependingProperty + dependantproperty = self.DependantProperty + + assert dependingproperty != dependantproperty + + + + + +class IfcPropertyEnumeratedValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeratedValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + enumerationvalues = self.EnumerationValues + enumerationreference = self.EnumerationReference + + assert (not exists(enumerationreference)) or (not exists(enumerationvalues)) or ((sizeof([temp for temp in enumerationvalues if temp in enumerationreference.EnumerationValues])) == sizeof(enumerationvalues)) + + + + + +class IfcPropertyEnumeration_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeration" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.EnumerationValues if not (typeof(self.EnumerationValues[1 - 1])) == typeof(temp)])) == 0 + + + + + +class IfcPropertyListValue_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyListValue" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.ListValues if not (typeof(self.ListValues[1 - 1])) == typeof(temp)])) == 0 + + + + + + + + +class IfcPropertySet_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySet_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + + + + +class IfcPropertySetTemplate_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySetTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + + + + + +class IfcPropertyTableValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + definedvalues = self.DefinedValues + + assert ((not exists(definingvalues)) and (not exists(definedvalues))) or (sizeof(definingvalues) == sizeof(definedvalues)) + + + + +class IfcPropertyTableValue_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + + assert (not exists(definingvalues)) or ((sizeof([temp for temp in self.DefiningValues if typeof(temp) != (typeof(self.DefiningValues[1 - 1]))])) == 0) + + + + +class IfcPropertyTableValue_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + definedvalues = self.DefinedValues + + assert (not exists(definedvalues)) or ((sizeof([temp for temp in self.DefinedValues if typeof(temp) != (typeof(self.DefinedValues[1 - 1]))])) == 0) + + + + + + + + + + + +class IfcProtectiveDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcprotectivedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcprotectivedevicetrippingunittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProtectiveDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPump_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPump_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcpumptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPumpType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPumpType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcQuantityArea_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.AREAUNIT) + + + + +class IfcQuantityArea_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + areavalue = self.AreaValue + + assert areavalue >= 0. + + + + + +class IfcQuantityCount_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityCount" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + countvalue = self.CountValue + + assert countvalue >= 0 + + + + + +class IfcQuantityLength_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + +class IfcQuantityLength_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + lengthvalue = self.LengthValue + + assert lengthvalue >= 0. + + + + + + + + + + + +class IfcQuantityTime_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.TIMEUNIT) + + + + +class IfcQuantityTime_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + timevalue = self.TimeValue + + assert timevalue >= 0. + + + + + +class IfcQuantityVolume_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.VOLUMEUNIT) + + + + +class IfcQuantityVolume_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + volumevalue = self.VolumeValue + + assert volumevalue >= 0. + + + + + +class IfcQuantityWeight_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.MASSUNIT) + + + + +class IfcQuantityWeight_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + weightvalue = self.WeightValue + + assert weightvalue >= 0. + + + + + +class IfcRail_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRail" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRail_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRail" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcrailtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRailing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRailing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcrailingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRailway_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailway" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailwayTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailwayTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcRailwayPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailwayPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailwayPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailwayPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcRamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcramptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRampFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcrampflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRationalBSplineCurveWithKnots_SameNumOfWeightsAndPoints: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "SameNumOfWeightsAndPoints" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert sizeof(weightsdata) == sizeof(self.ControlPointsList) + + + + +class IfcRationalBSplineCurveWithKnots_WeightsGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "WeightsGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcCurveWeightsPositive(self) + + + + +def calc_IfcRationalBSplineCurveWithKnots_Weights(self): + weightsdata = self.WeightsData + return \ + IfcListToArray(weightsdata,0,self.UpperIndexOnControlPoints) + + + + +class IfcRationalBSplineSurfaceWithKnots_CorrespondingWeightsDataLists: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingWeightsDataLists" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert (sizeof(weightsdata) == sizeof(self.ControlPointsList)) and ((sizeof(weightsdata[1 - 1])) == (sizeof(self.ControlPointsList[1 - 1]))) + + + + +class IfcRationalBSplineSurfaceWithKnots_WeightValuesGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "WeightValuesGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcSurfaceWeightsPositive(self) + + + + +def calc_IfcRationalBSplineSurfaceWithKnots_Weights(self): + uupper = self.UUpper + vupper = self.VUpper + weightsdata = self.WeightsData + return \ + IfcMakeArrayOfArray(weightsdata,0,uupper,0,vupper) + + + + +class IfcRectangleHollowProfileDef_ValidInnerRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidInnerRadius" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + innerfilletradius = self.InnerFilletRadius + + assert (not exists(innerfilletradius)) or ((innerfilletradius <= ((self.XDim / 2.) - wallthickness)) and (innerfilletradius <= ((self.YDim / 2.) - wallthickness))) + + + + +class IfcRectangleHollowProfileDef_ValidOuterRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidOuterRadius" + + @staticmethod + def __call__(self): + outerfilletradius = self.OuterFilletRadius + + assert (not exists(outerfilletradius)) or ((outerfilletradius <= (self.XDim / 2.)) and (outerfilletradius <= (self.YDim / 2.))) + + + + +class IfcRectangleHollowProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert (wallthickness < (self.XDim / 2.)) and (wallthickness < (self.YDim / 2.)) + + + + + + + + + + + +class IfcRectangularTrimmedSurface_U1AndU2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "U1AndU2Different" + + @staticmethod + def __call__(self): + u1 = self.U1 + u2 = self.U2 + + assert u1 != u2 + + + + +class IfcRectangularTrimmedSurface_UsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "UsenseCompatible" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + u1 = self.U1 + u2 = self.U2 + usense = self.Usense + + assert (('ifc4x3_add1.ifcelementarysurface' in typeof(basissurface)) and (not 'ifc4x3_add1.ifcplane' in typeof(basissurface))) or ('ifc4x3_add1.ifcsurfaceofrevolution' in typeof(basissurface)) or (usense == (u2 > u1)) + + + + +class IfcRectangularTrimmedSurface_V1AndV2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "V1AndV2Different" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + + assert v1 != v2 + + + + +class IfcRectangularTrimmedSurface_VsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "VsenseCompatible" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + vsense = self.Vsense + + assert vsense == (v2 > v1) + + + + + + + + + + + + + + + + + +class IfcReinforcedSoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcedSoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcedSoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcedSoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcReinforcingBar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingBar_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcreinforcingbartype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingBarType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + +class IfcReinforcingBarType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcReinforcingMesh_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingMesh_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcreinforcingmeshtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingMeshType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + +class IfcReinforcingMeshType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcRelAggregates_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAggregates" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + + + + +class IfcRelAssignsToActor_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToActor" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingactor = self.RelatingActor + + assert (sizeof([temp for temp in self.RelatedObjects if relatingactor == temp])) == 0 + + + + + +class IfcRelAssignsToControl_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToControl" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontrol = self.RelatingControl + + assert (sizeof([temp for temp in self.RelatedObjects if relatingcontrol == temp])) == 0 + + + + + +class IfcRelAssignsToGroup_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToGroup" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatinggroup = self.RelatingGroup + + assert (sizeof([temp for temp in self.RelatedObjects if relatinggroup == temp])) == 0 + + + + + + + + +class IfcRelAssignsToProcess_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProcess" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + + assert (sizeof([temp for temp in self.RelatedObjects if relatingprocess == temp])) == 0 + + + + + +class IfcRelAssignsToProduct_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProduct" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingproduct = self.RelatingProduct + + assert (sizeof([temp for temp in self.RelatedObjects if relatingproduct == temp])) == 0 + + + + + +class IfcRelAssignsToResource_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToResource" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingresource = self.RelatingResource + + assert (sizeof([temp for temp in self.RelatedObjects if relatingresource == temp])) == 0 + + + + + + + + + + + + + + + + + + + + + + + +class IfcRelAssociatesMaterial_AllowedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "AllowedElements" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if (sizeof(typeof(temp) * ['ifc4x3_add1.ifcelement','ifc4x3_add1.ifcelementtype','ifc4x3_add1.ifcstructuralmember','ifc4x3_add1.ifcport'])) == 0])) == 0 + + + + +class IfcRelAssociatesMaterial_NoVoidElement: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "NoVoidElement" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if ('ifc4x3_add1.ifcfeatureelementsubtraction' in typeof(temp)) or ('ifc4x3_add1.ifcvirtualelement' in typeof(temp))])) == 0 + + + + + + + + + + + +class IfcRelConnectsElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelConnectsPathElements_NormalizedRelatedPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatedPriorities" + + @staticmethod + def __call__(self): + relatedpriorities = self.RelatedPriorities + + assert (sizeof(relatedpriorities) == 0) or ((sizeof([temp for temp in relatedpriorities if 0 <= temp <= 100])) == sizeof(relatedpriorities)) + + + + +class IfcRelConnectsPathElements_NormalizedRelatingPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatingPriorities" + + @staticmethod + def __call__(self): + relatingpriorities = self.RelatingPriorities + + assert (sizeof(relatingpriorities) == 0) or ((sizeof([temp for temp in relatingpriorities if 0 <= temp <= 100])) == sizeof(relatingpriorities)) + + + + + + + + +class IfcRelConnectsPorts_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPorts" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingport = self.RelatingPort + relatedport = self.RelatedPort + + assert relatingport != relatedport + + + + + + + + + + + + + + + + + +class IfcRelContainedInSpatialStructure_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRelContainedInSpatialStructure" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if 'ifc4x3_add1.ifcspatialstructureelement' in typeof(temp)])) == 0 + + + + + + + + + + + +class IfcRelDeclares_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelDeclares" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontext = self.RelatingContext + relateddefinitions = self.RelatedDefinitions + + assert (sizeof([temp for temp in relateddefinitions if relatingcontext == temp])) == 0 + + + + + + + + + + + + + + +class IfcRelDefinesByProperties_NoRelatedTypeObject: + SCOPE = "entity" + TYPE_NAME = "IfcRelDefinesByProperties" + RULE_NAME = "NoRelatedTypeObject" + + @staticmethod + def __call__(self): + + + assert (sizeof([types for types in self.RelatedObjects if 'ifc4x3_add1.ifctypeobject' in typeof(types)])) == 0 + + + + + + + + + + + + + + + + + +class IfcRelInterferesElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelInterferesElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelNests_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelNests" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelPositions_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelPositions" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingpositioningelement = self.RelatingPositioningElement + relatedproducts = self.RelatedProducts + + assert (sizeof([temp for temp in relatedproducts if relatingpositioningelement == temp])) == 0 + + + + + + + + +class IfcRelReferencedInSpatialStructure_AllowedRelatedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelReferencedInSpatialStructure" + RULE_NAME = "AllowedRelatedElements" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if ('ifc4x3_add1.ifcspatialstructureelement' in typeof(temp)) and (not 'ifc4x3_add1.ifcspace' in typeof(temp))])) == 0 + + + + + +class IfcRelSequence_AvoidInconsistentSequence: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "AvoidInconsistentSequence" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + relatedprocess = self.RelatedProcess + + assert relatingprocess != relatedprocess + + + + +class IfcRelSequence_CorrectSequenceType: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "CorrectSequenceType" + + @staticmethod + def __call__(self): + sequencetype = self.SequenceType + userdefinedsequencetype = self.UserDefinedSequenceType + + assert (sequencetype != IfcSequenceEnum.USERDEFINED) or ((sequencetype == IfcSequenceEnum.USERDEFINED) and exists(userdefinedsequencetype)) + + + + + + + + +class IfcRelSpaceBoundary_CorrectPhysOrVirt: + SCOPE = "entity" + TYPE_NAME = "IfcRelSpaceBoundary" + RULE_NAME = "CorrectPhysOrVirt" + + @staticmethod + def __call__(self): + relatedbuildingelement = self.RelatedBuildingElement + physicalorvirtualboundary = self.PhysicalOrVirtualBoundary + + assert ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Physical) and (not 'ifc4x3_add1.ifcvirtualelement' in typeof(relatedbuildingelement))) or ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Virtual) and (('ifc4x3_add1.ifcvirtualelement' in typeof(relatedbuildingelement)) or ('ifc4x3_add1.ifcopeningelement' in typeof(relatedbuildingelement)))) or (physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.NotDefined) + + + + + + + + + + + + + + + + + +class IfcReparametrisedCompositeCurveSegment_PositiveLengthParameter: + SCOPE = "entity" + TYPE_NAME = "IfcReparametrisedCompositeCurveSegment" + RULE_NAME = "PositiveLengthParameter" + + @staticmethod + def __call__(self): + paramlength = self.ParamLength + + assert paramlength > 0.0 + + + + + + + + + + + + + + +class IfcRepresentationMap_ApplicableMappedRepr: + SCOPE = "entity" + TYPE_NAME = "IfcRepresentationMap" + RULE_NAME = "ApplicableMappedRepr" + + @staticmethod + def __call__(self): + mappedrepresentation = self.MappedRepresentation + + assert 'ifc4x3_add1.ifcshapemodel' in typeof(mappedrepresentation) + + + + + + + + + + + + + + + + + + + + +class IfcRevolvedAreaSolid_AxisDirectionInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisDirectionInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Z.DirectionRatios[3 - 1]) == 0.0 + + + + +class IfcRevolvedAreaSolid_AxisStartInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisStartInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert ('ifc4x3_add1.ifccartesianpoint' in typeof(axis.Location)) and ((axis.Location.Coordinates[3 - 1]) == 0.0) + + + + +def calc_IfcRevolvedAreaSolid_AxisLine(self): + axis = self.Axis + return \ + IfcLine(Pnt=axis.Location, Dir=IfcVector(Orientation=axis.Z, Magnitude=1.0)) + + + + +class IfcRevolvedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + + + + + + + +class IfcRigidOperation_SameCoordinateType: + SCOPE = "entity" + TYPE_NAME = "IfcRigidOperation" + RULE_NAME = "SameCoordinateType" + + @staticmethod + def __call__(self): + firstcoordinate = self.FirstCoordinate + secondcoordinate = self.SecondCoordinate + + assert (('ifc4x3_add1.ifclengthmeasure' in typeof(firstcoordinate)) and ('ifc4x3_add1.ifclengthmeasure' in typeof(secondcoordinate))) or (('ifc4x3_add1.ifcplaneanglemeasure' in typeof(firstcoordinate)) and ('ifc4x3_add1.ifcplaneanglemeasure' in typeof(secondcoordinate))) + + + + + +class IfcRoad_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoad" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoadTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoadTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcRoadPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoadPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoadPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoadPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcRoof_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRoof_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcrooftype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRoofType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoofType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcRoundedRectangleProfileDef_ValidRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRoundedRectangleProfileDef" + RULE_NAME = "ValidRadius" + + @staticmethod + def __call__(self): + roundingradius = self.RoundingRadius + + assert (roundingradius <= (self.XDim / 2.)) and (roundingradius <= (self.YDim / 2.)) + + + + + +def calc_IfcSIUnit_Dimensions(self): + + return \ + IfcDimensionsForSIUnit(self.Name) + + + + +class IfcSanitaryTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSanitaryTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcsanitaryterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSanitaryTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSeamCurve_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) == (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + +class IfcSeamCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + + + + + + + + + + + +class IfcSectionedSolid_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSolid_DirectrixIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "DirectrixIs3D" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSectionedSolid_SectionsSameType: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "SectionsSameType" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (typeof(crosssections[1 - 1])) != typeof(temp)])) == 0 + + + + + +class IfcSectionedSolidHorizontal_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSolidHorizontal_NoLongitudinalOffsets: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "NoLongitudinalOffsets" + + @staticmethod + def __call__(self): + crosssectionpositions = self.CrossSectionPositions + + assert (sizeof([temp for temp in crosssectionpositions if exists(temp.Location.OffsetLongitudinal)])) == 0 + + + + + +class IfcSectionedSpine_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSpine_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSpine_SpineCurveDim: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "SpineCurveDim" + + @staticmethod + def __call__(self): + spinecurve = self.SpineCurve + + assert spinecurve.Dim == 3 + + + + +def calc_IfcSectionedSpine_Dim(self): + + return \ + 3 + + + + +class IfcSectionedSurface_AreaProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSurface" + RULE_NAME = "AreaProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if temp.ProfileType == IfcProfileTypeEnum.CURVE])) == 0 + + + + +class IfcSectionedSurface_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSurface" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssectionpositions = self.CrossSectionPositions + crosssections = self.CrossSections + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSurface_DirectrixIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSurface" + RULE_NAME = "DirectrixIs3D" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSectionedSurface_NoOffsets: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSurface" + RULE_NAME = "NoOffsets" + + @staticmethod + def __call__(self): + crosssectionpositions = self.CrossSectionPositions + + assert (sizeof([temp for temp in crosssectionpositions if exists(temp.Location.OffsetLateral) or exists(temp.Location.OffsetVertical) or exists(temp.Location.OffsetLongitudinal)])) == 0 + + + + +class IfcSectionedSurface_SectionsSameType: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSurface" + RULE_NAME = "SectionsSameType" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (typeof(crosssections[1 - 1])) != typeof(temp)])) == 0 + + + + + +def calc_IfcSegment_Dim(self): + + return \ + IfcSegmentDim(self) + + + + + + + +class IfcSensor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSensor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcsensortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSensorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcShadingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcShadingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcshadingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcShadingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcShapeModel_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcShapeModel" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + ofshapeaspect = self.OfShapeAspect + + assert (sizeof(self.OfProductRepresentation) == 1) ^ (sizeof(self.RepresentationMap) == 1) ^ (sizeof(ofshapeaspect) == 1) + + + + + +class IfcShapeRepresentation_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_add1.ifcgeometricrepresentationcontext' in typeof(self.ContextOfItems) + + + + +class IfcShapeRepresentation_CorrectItemsForType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectItemsForType" + + @staticmethod + def __call__(self): + + + assert IfcShapeRepresentationTypes(self.RepresentationType,self.Items) + + + + +class IfcShapeRepresentation_HasRepresentationIdentifier: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationIdentifier" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationIdentifier) + + + + +class IfcShapeRepresentation_HasRepresentationType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationType" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcShapeRepresentation_NoTopologicalItem: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "NoTopologicalItem" + + @staticmethod + def __call__(self): + items = self.Items + + assert (sizeof([temp for temp in items if ('ifc4x3_add1.ifctopologicalrepresentationitem' in typeof(temp)) and (not (sizeof(['ifc4x3_add1.ifcvertexpoint','ifc4x3_add1.ifcedgecurve','ifc4x3_add1.ifcfacesurface'] * typeof(temp))) == 1)])) == 0 + + + + + +def calc_IfcShellBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + +class IfcSign_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSign" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSignTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSign_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSign" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcsigntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSignType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSignTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSignal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSignalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSignal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSignal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcsignaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSignalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSignalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + +class IfcSlab_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSlab_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcslabtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSlabType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlabType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSolarDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSolarDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcsolardevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSolarDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcSolidModel_Dim(self): + + return \ + 3 + + + + +class IfcSpace_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpace_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcspacetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeater_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpaceHeater_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcspaceheatertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeaterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeaterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSpaceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcSpatialStructureElement_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialStructureElement" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + + + assert (hiindex(self.Decomposes) == 1) and ('ifc4x3_add1.ifcrelaggregates' in (typeof(self.Decomposes[1 - 1]))) and (('ifc4x3_add1.ifcproject' in (typeof(self.Decomposes[1 - 1].RelatingObject))) or ('ifc4x3_add1.ifcspatialstructureelement' in (typeof(self.Decomposes[1 - 1].RelatingObject)))) + + + + + + + + +class IfcSpatialZone_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpatialZone_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcspatialzonetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpatialZoneType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZoneType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcStackTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStackTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcstackterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStackTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStair_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStair_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcstairtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStairFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcstairflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStairType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcStructuralAnalysisModel_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralAnalysisModel" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAnalysisModelTypeEnum.USERDEFINED) or ((predefinedtype == IfcAnalysisModelTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcStructuralCurveAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralCurveAction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert predefinedtype != IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + + + + + + + +class IfcStructuralCurveMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralCurveReaction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveReaction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.SINUS) and (predefinedtype != IfcStructuralCurveActivityTypeEnum.PARABOLA) + + + + + + + + +class IfcStructuralLinearAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralCurveActivityTypeEnum.CONST + + + + +class IfcStructuralLinearAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_add1.ifcstructuralloadlinearforce','ifc4x3_add1.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralLoadCase_IsLoadCasePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadCase" + RULE_NAME = "IsLoadCasePredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcLoadGroupTypeEnum.LOAD_CASE + + + + + +class IfcStructuralLoadConfiguration_ValidListSize: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadConfiguration" + RULE_NAME = "ValidListSize" + + @staticmethod + def __call__(self): + values = self.Values + locations = self.Locations + + assert (not exists(locations)) or (sizeof(locations) == sizeof(values)) + + + + + +class IfcStructuralLoadGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + actiontype = self.ActionType + actionsource = self.ActionSource + + assert ((predefinedtype != IfcLoadGroupTypeEnum.USERDEFINED) and (actiontype != IfcActionTypeEnum.USERDEFINED) and (actionsource != IfcActionSourceTypeEnum.USERDEFINED)) or exists(self.ObjectType) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcStructuralPlanarAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralSurfaceActivityTypeEnum.CONST + + + + +class IfcStructuralPlanarAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_add1.ifcstructuralloadplanarforce','ifc4x3_add1.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + + +class IfcStructuralPointAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_add1.ifcstructuralloadsingleforce','ifc4x3_add1.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralPointReaction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointReaction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_add1.ifcstructuralloadsingleforce','ifc4x3_add1.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralResultGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralResultGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + theorytype = self.TheoryType + + assert (theorytype != IfcAnalysisTheoryTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcStructuralSurfaceAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralSurfaceAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + + + + + +class IfcStructuralSurfaceMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceReaction_HasPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceReaction" + RULE_NAME = "HasPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStyledItem_ApplicableItem: + SCOPE = "entity" + TYPE_NAME = "IfcStyledItem" + RULE_NAME = "ApplicableItem" + + @staticmethod + def __call__(self): + item = self.Item + + assert not 'ifc4x3_add1.ifcstyleditem' in typeof(item) + + + + + +class IfcStyledRepresentation_OnlyStyledItems: + SCOPE = "entity" + TYPE_NAME = "IfcStyledRepresentation" + RULE_NAME = "OnlyStyledItems" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x3_add1.ifcstyleditem' in typeof(temp)])) == 0 + + + + + +class IfcSubContractResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcSubContractResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +def calc_IfcSurface_Dim(self): + + return \ + 3 + + + + +class IfcSurfaceCurve_CurveIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIs3D" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert curve3d.Dim == 3 + + + + +class IfcSurfaceCurve_CurveIsNotPcurve: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIsNotPcurve" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert not 'ifc4x3_add1.ifcpcurve' in typeof(curve3d) + + + + +def calc_IfcSurfaceCurve_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + + + + +class IfcSurfaceFeature_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceFeature" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSurfaceFeatureTypeEnum.USERDEFINED) or ((predefinedtype == IfcSurfaceFeatureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcSurfaceOfLinearExtrusion_DepthGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceOfLinearExtrusion" + RULE_NAME = "DepthGreaterZero" + + @staticmethod + def __call__(self): + depth = self.Depth + + assert depth > 0. + + + + +def calc_IfcSurfaceOfLinearExtrusion_ExtrusionAxis(self): + extrudeddirection = self.ExtrudedDirection + depth = self.Depth + return \ + IfcVector(Orientation=extrudeddirection, Magnitude=depth) + + + + +def calc_IfcSurfaceOfRevolution_AxisLine(self): + axisposition = self.AxisPosition + return \ + IfcLine(Pnt=axisposition.Location, Dir=IfcVector(Orientation=axisposition.Z, Magnitude=1.0)) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea1: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea1" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + + assert (not exists(surfacereinforcement1)) or (((surfacereinforcement1[1 - 1]) >= 0.) and ((surfacereinforcement1[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement1) == 1) or ((surfacereinforcement1[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea2: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea2" + + @staticmethod + def __call__(self): + surfacereinforcement2 = self.SurfaceReinforcement2 + + assert (not exists(surfacereinforcement2)) or (((surfacereinforcement2[1 - 1]) >= 0.) and ((surfacereinforcement2[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement2) == 1) or ((surfacereinforcement2[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea3: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea3" + + @staticmethod + def __call__(self): + shearreinforcement = self.ShearReinforcement + + assert (not exists(shearreinforcement)) or (shearreinforcement >= 0.) + + + + +class IfcSurfaceReinforcementArea_SurfaceAndOrShearAreaSpecified: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "SurfaceAndOrShearAreaSpecified" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + surfacereinforcement2 = self.SurfaceReinforcement2 + shearreinforcement = self.ShearReinforcement + + assert exists(surfacereinforcement1) or exists(surfacereinforcement2) or exists(shearreinforcement) + + + + + +class IfcSurfaceStyle_MaxOneExtDefined: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneExtDefined" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_add1.ifcexternallydefinedsurfacestyle' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneLighting: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneLighting" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_add1.ifcsurfacestylelighting' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneRefraction: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneRefraction" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_add1.ifcsurfacestylerefraction' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneShading: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneShading" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_add1.ifcsurfacestyleshading' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneTextures: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneTextures" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_add1.ifcsurfacestylewithtextures' in typeof(style)])) <= 1 + + + + + + + + + + + + + + + + + + + + + + + +class IfcSweptAreaSolid_SweptAreaType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptAreaSolid" + RULE_NAME = "SweptAreaType" + + @staticmethod + def __call__(self): + sweptarea = self.SweptArea + + assert sweptarea.ProfileType == IfcProfileTypeEnum.Area + + + + + +class IfcSweptDiskSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x3_add1.ifcconic','ifc4x3_add1.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + +class IfcSweptDiskSolid_DirectrixDim: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixDim" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSweptDiskSolid_InnerRadiusSize: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "InnerRadiusSize" + + @staticmethod + def __call__(self): + radius = self.Radius + innerradius = self.InnerRadius + + assert (not exists(innerradius)) or (radius > innerradius) + + + + + +class IfcSweptDiskSolidPolygonal_CorrectRadii: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "CorrectRadii" + + @staticmethod + def __call__(self): + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or (filletradius >= self.Radius) + + + + +class IfcSweptDiskSolidPolygonal_DirectrixIsPolyline: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "DirectrixIsPolyline" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_add1.ifcpolyline' in typeof(self.Directrix)) or (('ifc4x3_add1.ifcindexedpolycurve' in typeof(self.Directrix)) and (not exists(self.Directrix.Segments))) + + + + + +class IfcSweptSurface_SweptCurveType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptSurface" + RULE_NAME = "SweptCurveType" + + @staticmethod + def __call__(self): + sweptcurve = self.SweptCurve + + assert sweptcurve.ProfileType == IfcProfileTypeEnum.Curve + + + + + +class IfcSwitchingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSwitchingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcswitchingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSwitchingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSystemFurnitureElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSystemFurnitureElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcsystemfurnitureelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSystemFurnitureElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < depth + + + + +class IfcTShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcTable_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + rows = self.Rows + + assert (sizeof([temp for temp in rows if hiindex(temp.RowCells) != (hiindex(rows[1 - 1].RowCells))])) == 0 + + + + +class IfcTable_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + numberofheadings = self.NumberOfHeadings + + assert 0 <= numberofheadings <= 1 + + + + +def calc_IfcTable_NumberOfCellsInRow(self): + rows = self.Rows + return \ + hiindex(rows[1 - 1].RowCells) + + + +def calc_IfcTable_NumberOfHeadings(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if temp.IsHeading]) + + + +def calc_IfcTable_NumberOfDataRows(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if not temp.IsHeading]) + + + + + + + + + + +class IfcTank_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTank_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifctanktype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTankType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTankType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTask_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTask_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + + + + + + + +class IfcTaskType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTaskType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + +class IfcTelecomAddress_MinimumDataProvided: + SCOPE = "entity" + TYPE_NAME = "IfcTelecomAddress" + RULE_NAME = "MinimumDataProvided" + + @staticmethod + def __call__(self): + telephonenumbers = self.TelephoneNumbers + facsimilenumbers = self.FacsimileNumbers + pagernumber = self.PagerNumber + electronicmailaddresses = self.ElectronicMailAddresses + wwwhomepageurl = self.WWWHomePageURL + messagingids = self.MessagingIDs + + assert exists(telephonenumbers) or exists(facsimilenumbers) or exists(pagernumber) or exists(electronicmailaddresses) or exists(wwwhomepageurl) or exists(messagingids) + + + + + +class IfcTendon_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendon_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifctendontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonAnchor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifctendonanchortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonConduit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonConduit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifctendonconduittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonConduitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcTessellatedFaceSet_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcTextLiteralWithExtent_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcTextLiteralWithExtent" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + extent = self.Extent + + assert not 'ifc4x3_add1.ifcplanarbox' in typeof(extent) + + + + + + + + +class IfcTextStyleFontModel_MeasureOfFontSize: + SCOPE = "entity" + TYPE_NAME = "IfcTextStyleFontModel" + RULE_NAME = "MeasureOfFontSize" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_add1.ifclengthmeasure' in typeof(self.FontSize)) and (self.FontSize > 0.) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTopologyRepresentation_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x3_add1.ifctopologicalrepresentationitem' in typeof(temp)])) == 0 + + + + +class IfcTopologyRepresentation_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcTopologyRepresentation_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + + + assert IfcTopologyRepresentationTypes(self.RepresentationType,self.Items) + + + + + +class IfcToroidalSurface_MajorLargerMinor: + SCOPE = "entity" + TYPE_NAME = "IfcToroidalSurface" + RULE_NAME = "MajorLargerMinor" + + @staticmethod + def __call__(self): + majorradius = self.MajorRadius + minorradius = self.MinorRadius + + assert minorradius < majorradius + + + + + +class IfcTrackElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTrackElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTrackElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTrackElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifctrackelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTrackElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTrackElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTrackElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTransformer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransformer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifctransformertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransformerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTransportElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransportElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransportElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransportElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifctransportelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransportElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransportElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransportElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +def calc_IfcTriangulatedFaceSet_NumberOfTriangles(self): + coordindex = self.CoordIndex + return \ + sizeof(coordindex) + + + + +class IfcTriangulatedIrregularNetwork_NotClosed: + SCOPE = "entity" + TYPE_NAME = "IfcTriangulatedIrregularNetwork" + RULE_NAME = "NotClosed" + + @staticmethod + def __call__(self): + + + assert self.Closed == False + + + + + +class IfcTrimmedCurve_NoTrimOfBoundedCurves: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "NoTrimOfBoundedCurves" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert not 'ifc4x3_add1.ifcboundedcurve' in typeof(basiscurve) + + + + +class IfcTrimmedCurve_Trim1ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim1ValuesConsistent" + + @staticmethod + def __call__(self): + trim1 = self.Trim1 + + assert (hiindex(trim1) == 1) or ((typeof(trim1[1 - 1])) != (typeof(trim1[2 - 1]))) + + + + +class IfcTrimmedCurve_Trim2ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim2ValuesConsistent" + + @staticmethod + def __call__(self): + trim2 = self.Trim2 + + assert (hiindex(trim2) == 1) or ((typeof(trim2[1 - 1])) != (typeof(trim2[2 - 1]))) + + + + + +class IfcTubeBundle_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTubeBundle_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifctubebundletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTubeBundleType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundleType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTypeObject_NameRequired: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "NameRequired" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTypeObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + haspropertysets = self.HasPropertySets + + assert (not exists(haspropertysets)) or IfcUniquePropertySetNames(haspropertysets) + + + + + + + + +class IfcTypeProduct_ApplicableOccurrence: + SCOPE = "entity" + TYPE_NAME = "IfcTypeProduct" + RULE_NAME = "ApplicableOccurrence" + + @staticmethod + def __call__(self): + + + assert (not exists(lambda: self.Types[1 - 1])) or ((sizeof([temp for temp in self.Types[1 - 1].RelatedObjects if not 'ifc4x3_add1.ifcproduct' in typeof(temp)])) == 0) + + + + + + + + +class IfcUShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + +class IfcUShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcUnitAssignment_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcUnitAssignment" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + units = self.Units + + assert IfcCorrectUnitAssignment(units) + + + + + +class IfcUnitaryControlElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryControlElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcunitarycontrolelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryControlElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcUnitaryEquipment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryEquipment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcunitaryequipmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryEquipmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcValve_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcValve_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcvalvetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcValveType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValveType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVector_MagGreaterOrEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcVector" + RULE_NAME = "MagGreaterOrEqualZero" + + @staticmethod + def __call__(self): + magnitude = self.Magnitude + + assert magnitude >= 0.0 + + + + +def calc_IfcVector_Dim(self): + orientation = self.Orientation + return \ + orientation.Dim + + + + +class IfcVehicle_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVehicle" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVehicleTypeEnum.USERDEFINED) or ((predefinedtype == IfcVehicleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVehicle_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVehicle" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcvehicletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVehicleType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVehicleType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVehicleTypeEnum.USERDEFINED) or ((predefinedtype == IfcVehicleTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcVibrationDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcvibrationdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVibrationIsolator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationIsolator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcvibrationisolatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationIsolatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVirtualElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVirtualElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVirtualElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcVirtualElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcVoidingFeature_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVoidingFeature" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVoidingFeatureTypeEnum.USERDEFINED) or ((predefinedtype == IfcVoidingFeatureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWallStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcWallStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_add1.ifcrelassociates.relatedobjects') if ('ifc4x3_add1.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_add1.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWasteTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWasteTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcwasteterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWasteTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcWindow_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWindowTypeEnum.USERDEFINED) or ((predefinedtype == IfcWindowTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWindow_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_add1.ifcwindowtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWindowLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcWindowLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + firsttransomoffset = self.FirstTransomOffset + secondtransomoffset = self.SecondTransomOffset + + assert not (not exists(firsttransomoffset)) and exists(secondtransomoffset) + + + + +class IfcWindowLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + firstmullionoffset = self.FirstMullionOffset + secondmullionoffset = self.SecondMullionOffset + + assert not (not exists(firstmullionoffset)) and exists(secondmullionoffset) + + + + +class IfcWindowLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and ('ifc4x3_add1.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) + + + + + +class IfcWindowPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and ('ifc4x3_add1.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) + + + + + +class IfcWindowType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWindowTypeEnum.USERDEFINED) or ((predefinedtype == IfcWindowTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWorkCalendar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkCalendar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkCalendarTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkCalendarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcWorkPlan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkPlan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkPlanTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkPlanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcWorkSchedule_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkSchedule" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkScheduleTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkScheduleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcZShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcZShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + + +class IfcZone_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcZone" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof(self.IsGroupedBy) == 0) or ((sizeof([temp for temp in self.IsGroupedBy[1 - 1].RelatedObjects if not ('ifc4x3_add1.ifczone' in typeof(temp)) or ('ifc4x3_add1.ifcspace' in typeof(temp)) or ('ifc4x3_add1.ifcspatialzone' in typeof(temp))])) == 0) + + + + + +class IfcRepresentationContextSameWCS: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcGeometricRepresentationContext = file.by_type("IfcGeometricRepresentationContext") + isdifferent = False + if sizeof(IfcGeometricRepresentationContext) > 1: + for i in range(2, hiindex(IfcGeometricRepresentationContext) + 1): + if (IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem) != (IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem): + isdifferent = (not IfcSameValidPrecision(IfcGeometricRepresentationContext[1 - 1].Precision,IfcGeometricRepresentationContext[i - 1].Precision)) or (not IfcSameAxis2Placement(IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[1 - 1].Precision)) + if isdifferent == True: + break + + assert isdifferent == False + + + + + +class IfcSingleProjectInstance: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcProject = file.by_type("IfcProject") + + + + assert sizeof(IfcProject) <= 1 + + + + +def IfcAssociatedSurface(arg): + + surf = arg.BasisSurface + return surf + + +def IfcBaseAxis(dim, axis1, axis2, axis3): + + + + if dim == 3: + d1 = nvl(IfcNormalise(axis3),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,axis1) + u = [d2,IfcSecondProjAxis(d1,d2,axis2),d1] + else: + if exists(axis1): + d1 = IfcNormalise(axis1) + u = [d1,IfcOrthogonalComplement(d1)] + if exists(axis2): + factor = IfcDotProduct(axis2,u[2 - 1]) + if factor < 0.0: + u[2 - 1].DirectionRatios[1 - 1] = -u[2 - 1].DirectionRatios[1 - 1] + u[2 - 1].DirectionRatios[2 - 1] = -u[2 - 1].DirectionRatios[2 - 1] + else: + if exists(axis2): + d1 = IfcNormalise(axis2) + u = [IfcOrthogonalComplement(d1),d1] + u[1 - 1].DirectionRatios[1 - 1] = -u[1 - 1].DirectionRatios[1 - 1] + u[1 - 1].DirectionRatios[2 - 1] = -u[1 - 1].DirectionRatios[2 - 1] + else: + u = [IfcDirection(DirectionRatios=[1.0,0.0]),IfcDirection(DirectionRatios=[0.0,1.0])] + return u + + +def IfcBooleanChoose(b, choice1, choice2): + + if b: + return choice1 + else: + return choice2 + + +def IfcBuild2Axes(refdirection): + d = nvl(IfcNormalise(refdirection),IfcDirection(DirectionRatios=[1.0,0.0])) + return [d,IfcOrthogonalComplement(d)] + + +def IfcBuildAxes(axis, refdirection): + + d1 = nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,refdirection) + return [d2,IfcNormalise(IfcCrossProduct(d1,d2)).Orientation,d1] + + +def IfcConsecutiveSegments(segments): + result = True + for i in range(1, hiindex(segments) - 1 + 1): + if (segments[i - 1][hiindex(segments[i - 1]) - 1]) != (segments[i - 1][1 - 1]): + result = False + break + return result + + +def IfcConstraintsParamBSpline(degree, upknots, upcp, knotmult, knots): + result = True + + sum = knotmult[1 - 1] + for i in range(2, upknots + 1): + sum = sum + (knotmult[i - 1]) + if (degree < 1) or (upknots < 2) or (upcp < degree) or (sum != (degree + upcp + 2)): + result = False + return result + k = knotmult[1 - 1] + if (k < 1) or (k > (degree + 1)): + result = False + return result + for i in range(2, upknots + 1): + if ((knotmult[i - 1]) < 1) or ((knots[i - 1]) <= (knots[i - 1])): + result = False + return result + k = knotmult[i - 1] + if (i < upknots) and (k > degree): + result = False + return result + if (i == upknots) and (k > (degree + 1)): + result = False + return result + return result + + +def IfcConvertDirectionInto2D(direction): + direction2d = IfcDirection(DirectionRatios=[0.,1.]) + temp = list(direction2d.DirectionRatios) + temp[1 - 1] = direction.DirectionRatios[1 - 1] + direction2d.DirectionRatios = temp + temp = list(direction2d.DirectionRatios) + temp[2 - 1] = direction.DirectionRatios[2 - 1] + direction2d.DirectionRatios = temp + return direction2d + + +def IfcCorrectDimensions(m, dim): + + if m == lengthunit: + if dim == IfcDimensionalExponents(1,0,0,0,0,0,0): + return True + else: + return False + elif m == massunit: + if dim == IfcDimensionalExponents(0,1,0,0,0,0,0): + return True + else: + return False + elif m == timeunit: + if dim == IfcDimensionalExponents(0,0,1,0,0,0,0): + return True + else: + return False + elif m == electriccurrentunit: + if dim == IfcDimensionalExponents(0,0,0,1,0,0,0): + return True + else: + return False + elif m == thermodynamictemperatureunit: + if dim == IfcDimensionalExponents(0,0,0,0,1,0,0): + return True + else: + return False + elif m == amountofsubstanceunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,1,0): + return True + else: + return False + elif m == luminousintensityunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == planeangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == solidangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == areaunit: + if dim == IfcDimensionalExponents(2,0,0,0,0,0,0): + return True + else: + return False + elif m == volumeunit: + if dim == IfcDimensionalExponents(3,0,0,0,0,0,0): + return True + else: + return False + elif m == absorbeddoseunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == radioactivityunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == electriccapacitanceunit: + if dim == IfcDimensionalExponents(-2,-1,4,2,0,0,0): + return True + else: + return False + elif m == doseequivalentunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == electricchargeunit: + if dim == IfcDimensionalExponents(0,0,1,1,0,0,0): + return True + else: + return False + elif m == electricconductanceunit: + if dim == IfcDimensionalExponents(-2,-1,3,2,0,0,0): + return True + else: + return False + elif m == electricvoltageunit: + if dim == IfcDimensionalExponents(2,1,-3,-1,0,0,0): + return True + else: + return False + elif m == electricresistanceunit: + if dim == IfcDimensionalExponents(2,1,-3,-2,0,0,0): + return True + else: + return False + elif m == energyunit: + if dim == IfcDimensionalExponents(2,1,-2,0,0,0,0): + return True + else: + return False + elif m == forceunit: + if dim == IfcDimensionalExponents(1,1,-2,0,0,0,0): + return True + else: + return False + elif m == frequencyunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == inductanceunit: + if dim == IfcDimensionalExponents(2,1,-2,-2,0,0,0): + return True + else: + return False + elif m == illuminanceunit: + if dim == IfcDimensionalExponents(-2,0,0,0,0,0,1): + return True + else: + return False + elif m == luminousfluxunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == magneticfluxunit: + if dim == IfcDimensionalExponents(2,1,-2,-1,0,0,0): + return True + else: + return False + elif m == magneticfluxdensityunit: + if dim == IfcDimensionalExponents(0,1,-2,-1,0,0,0): + return True + else: + return False + elif m == powerunit: + if dim == IfcDimensionalExponents(2,1,-3,0,0,0,0): + return True + else: + return False + elif m == pressureunit: + if dim == IfcDimensionalExponents(-1,1,-2,0,0,0,0): + return True + else: + return False + else: + return unknown + + +def IfcCorrectFillAreaStyle(styles): + hatching = 0 + tiles = 0 + colour = 0 + external = 0 + external = sizeof([style for style in styles if 'ifc4x3_add1.ifcexternallydefinedhatchstyle' in typeof(style)]) + hatching = sizeof([style for style in styles if 'ifc4x3_add1.ifcfillareastylehatching' in typeof(style)]) + tiles = sizeof([style for style in styles if 'ifc4x3_add1.ifcfillareastyletiles' in typeof(style)]) + colour = sizeof([style for style in styles if 'ifc4x3_add1.ifccolour' in typeof(style)]) + if external > 1: + return False + if (external == 1) and ((hatching > 0) or (tiles > 0) or (colour > 0)): + return False + if colour > 1: + return False + if (hatching > 0) and (tiles > 0): + return False + return True + + +def IfcCorrectLocalPlacement(axisplacement, relplacement): + + if exists(relplacement): + if 'ifc4x3_add1.ifcgridplacement' in typeof(relplacement): + return None + if 'ifc4x3_add1.ifclocalplacement' in typeof(relplacement): + if 'ifc4x3_add1.ifcaxis2placement2d' in typeof(axisplacement): + return True + if 'ifc4x3_add1.ifcaxis2placement3d' in typeof(axisplacement): + if relplacement.RelativePlacement.Dim == 3: + return True + else: + return False + return True + return None + + +def IfcCorrectUnitAssignment(units): + namedunitnumber = 0 + derivedunitnumber = 0 + monetaryunitnumber = 0 + namedunitnames = express_set([]) + derivedunitnames = express_set([]) + namedunitnumber = sizeof([temp for temp in units if ('ifc4x3_add1.ifcnamedunit' in typeof(temp)) and (not temp.UnitType == IfcUnitEnum.USERDEFINED)]) + derivedunitnumber = sizeof([temp for temp in units if ('ifc4x3_add1.ifcderivedunit' in typeof(temp)) and (not temp.UnitType == IfcDerivedUnitEnum.USERDEFINED)]) + monetaryunitnumber = sizeof([temp for temp in units if 'ifc4x3_add1.ifcmonetaryunit' in typeof(temp)]) + for i in range(1, sizeof(units) + 1): + if ('ifc4x3_add1.ifcnamedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcUnitEnum.USERDEFINED): + namedunitnames = namedunitnames + (units[i - 1].UnitType) + if ('ifc4x3_add1.ifcderivedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcDerivedUnitEnum.USERDEFINED): + derivedunitnames = derivedunitnames + (units[i - 1].UnitType) + return (sizeof(namedunitnames) == namedunitnumber) and (sizeof(derivedunitnames) == derivedunitnumber) and (monetaryunitnumber <= 1) + + +def IfcCrossProduct(arg1, arg2): + + + + + if ((not exists(arg1)) or (arg1.Dim == 2)) or ((not exists(arg2)) or (arg2.Dim == 2)): + return None + else: + v1 = IfcNormalise(arg1).DirectionRatios + v2 = IfcNormalise(arg2).DirectionRatios + res = IfcDirection(DirectionRatios=[((v1[2 - 1]) * (v2[3 - 1])) - ((v1[3 - 1]) * (v2[2 - 1])),((v1[3 - 1]) * (v2[1 - 1])) - ((v1[1 - 1]) * (v2[3 - 1])),((v1[1 - 1]) * (v2[2 - 1])) - ((v1[2 - 1]) * (v2[1 - 1]))]) + mag = 0.0 + for i in range(1, 3 + 1): + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=arg1, Magnitude=0.0) + return result + + +def IfcCurveDim(curve): + + if 'ifc4x3_add1.ifcline' in typeof(curve): + return curve.Pnt.Dim + if 'ifc4x3_add1.ifcconic' in typeof(curve): + return curve.Position.Dim + if 'ifc4x3_add1.ifcpolyline' in typeof(curve): + return curve.Points[1 - 1].Dim + if 'ifc4x3_add1.ifctrimmedcurve' in typeof(curve): + return IfcCurveDim(curve.BasisCurve) + if 'ifc4x3_add1.ifcgradientcurve' in typeof(curve): + return 3 + if 'ifc4x3_add1.ifcsegmentedreferencecurve' in typeof(curve): + return 3 + if 'ifc4x3_add1.ifccompositecurve' in typeof(curve): + return curve.Segments[1 - 1].Dim + if 'ifc4x3_add1.ifcbsplinecurve' in typeof(curve): + return curve.ControlPointsList[1 - 1].Dim + if 'ifc4x3_add1.ifcoffsetcurve2d' in typeof(curve): + return 2 + if 'ifc4x3_add1.ifcoffsetcurve3d' in typeof(curve): + return 3 + if 'ifc4x3_add1.ifcoffsetcurvebydistances' in typeof(curve): + return 3 + if 'ifc4x3_add1.ifccurvesegment2d' in typeof(curve): + return 2 + if 'ifc4x3_add1.ifcpolynomialcurve' in typeof(curve): + if (not exists(curve.CoefficientsZ)) and (curve.Position.Dim == 2): + return 2 + return 3 + if 'ifc4x3_add1.ifcpcurve' in typeof(curve): + return 3 + if 'ifc4x3_add1.ifcindexedpolycurve' in typeof(curve): + return curve.Points.Dim + return None + + +def IfcCurveWeightsPositive(b): + result = True + for i in range(0, b.UpperIndexOnControlPoints + 1): + if (b.Weights[i - 1]) <= 0.0: + result = False + return result + return result + + +def IfcDeriveDimensionalExponents(unitelements): + result = IfcDimensionalExponents(0,0,0,0,0,0,0) + for i in range(loindex(unitelements), hiindex(unitelements) + 1): + result.LengthExponent = result.LengthExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LengthExponent)) + result.MassExponent = result.MassExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.MassExponent)) + result.TimeExponent = result.TimeExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.TimeExponent)) + result.ElectricCurrentExponent = result.ElectricCurrentExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ElectricCurrentExponent)) + result.ThermodynamicTemperatureExponent = result.ThermodynamicTemperatureExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ThermodynamicTemperatureExponent)) + result.AmountOfSubstanceExponent = result.AmountOfSubstanceExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.AmountOfSubstanceExponent)) + result.LuminousIntensityExponent = result.LuminousIntensityExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LuminousIntensityExponent)) + return result + + +def IfcDimensionsForSIUnit(n): + + if n == metre: + return IfcDimensionalExponents(1,0,0,0,0,0,0) + elif n == square_metre: + return IfcDimensionalExponents(2,0,0,0,0,0,0) + elif n == cubic_metre: + return IfcDimensionalExponents(3,0,0,0,0,0,0) + elif n == gram: + return IfcDimensionalExponents(0,1,0,0,0,0,0) + elif n == second: + return IfcDimensionalExponents(0,0,1,0,0,0,0) + elif n == ampere: + return IfcDimensionalExponents(0,0,0,1,0,0,0) + elif n == kelvin: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == mole: + return IfcDimensionalExponents(0,0,0,0,0,1,0) + elif n == candela: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == radian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == steradian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == hertz: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == newton: + return IfcDimensionalExponents(1,1,-2,0,0,0,0) + elif n == pascal: + return IfcDimensionalExponents(-1,1,-2,0,0,0,0) + elif n == joule: + return IfcDimensionalExponents(2,1,-2,0,0,0,0) + elif n == watt: + return IfcDimensionalExponents(2,1,-3,0,0,0,0) + elif n == coulomb: + return IfcDimensionalExponents(0,0,1,1,0,0,0) + elif n == volt: + return IfcDimensionalExponents(2,1,-3,-1,0,0,0) + elif n == farad: + return IfcDimensionalExponents(-2,-1,4,2,0,0,0) + elif n == ohm: + return IfcDimensionalExponents(2,1,-3,-2,0,0,0) + elif n == siemens: + return IfcDimensionalExponents(-2,-1,3,2,0,0,0) + elif n == weber: + return IfcDimensionalExponents(2,1,-2,-1,0,0,0) + elif n == tesla: + return IfcDimensionalExponents(0,1,-2,-1,0,0,0) + elif n == henry: + return IfcDimensionalExponents(2,1,-2,-2,0,0,0) + elif n == degree_celsius: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == lumen: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == lux: + return IfcDimensionalExponents(-2,0,0,0,0,0,1) + elif n == becquerel: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == gray: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + elif n == sievert: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + else: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + + +def IfcDotProduct(arg1, arg2): + + + + if (not exists(arg1)) or (not exists(arg2)): + scalar = None + else: + if arg1.Dim != arg2.Dim: + scalar = None + else: + vec1 = IfcNormalise(arg1) + vec2 = IfcNormalise(arg2) + ndim = arg1.Dim + scalar = 0.0 + for i in range(1, ndim + 1): + scalar = scalar + ((vec1.DirectionRatios[i - 1]) * (vec2.DirectionRatios[i - 1])) + return scalar + + +def IfcFirstProjAxis(zaxis, arg): + + + + + if not exists(zaxis): + return None + else: + z = IfcNormalise(zaxis) + if not exists(arg): + if z.DirectionRatios != [1.0,0.0,0.0]: + v = IfcDirection(DirectionRatios=[1.0,0.0,0.0]) + else: + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + if arg.Dim != 3: + return None + if IfcCrossProduct(arg,z).Magnitude == 0.0: + return None + else: + v = IfcNormalise(arg) + xvec = IfcScalarTimesVector(IfcDotProduct(v,z),z) + xaxis = IfcVectorDifference(v,xvec).Orientation + xaxis = IfcNormalise(xaxis) + return xaxis + + +def IfcGetBasisSurface(c): + + + surfs = [] + if 'ifc4x3_add1.ifcpcurve' in typeof(c): + surfs = [c.BasisSurface] + else: + if 'ifc4x3_add1.ifcsurfacecurve' in typeof(c): + n = sizeof(c.AssociatedGeometry) + for i in range(1, n + 1): + surfs = surfs + (IfcAssociatedSurface(c.AssociatedGeometry[i - 1])) + if 'ifc4x3_add1.ifccompositecurveonsurface' in typeof(c): + n = sizeof(c.Segments) + if 'ifc4x3_add1.ifccurvesegment' in (typeof(c.Segments[1 - 1])): + surfs = IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve) + if 'ifc4x3_add1.ifccompositecurvesegment' in (typeof(c.Segments[1 - 1])): + surfs = IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve) + if n > 1: + for i in range(2, n + 1): + if 'ifc4x3_add1.ifccurvesegment' in (typeof(c.Segments[i - 1])): + surfs = surfs * (IfcGetBasisSurface(c.Segments[i - 1].ParentCurve)) + if 'ifc4x3_add1.ifccompositecurvesegment' in (typeof(c.Segments[i - 1])): + surfs = surfs * (IfcGetBasisSurface(c.Segments[i - 1].ParentCurve)) + return surfs + + +def IfcListToArray(lis, low, u): + + + n = sizeof(lis) + if n != (u - low + 1): + return None + else: + res = ([lis[1 - 1]] * n) + for i in range(2, n + 1): + temp = list(res) + temp[low - 1] = lis[i - 1] + res = temp + return res + + +def IfcLoopHeadToTail(aloop): + + p = True + n = sizeof(aloop.EdgeList) + for i in range(2, n + 1): + p = p and ((aloop.EdgeList[i - 1].EdgeEnd) == (aloop.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcMakeArrayOfArray(lis, low1, u1, low2, u2): + + if (u1 - low1 + 1) != sizeof(lis): + return None + if (u2 - low2 + 1) != (sizeof(lis[1 - 1])): + return None + res = ([IfcListToArray(lis[1 - 1],low2,u2)] * u1 - low1 + 1) + for i in range(2, hiindex(lis) + 1): + if (u2 - low2 + 1) != (sizeof(lis[i - 1])): + return None + temp = list(res) + temp[low1 - 1] = IfcListToArray(lis[i - 1],low2,u2) + res = temp + return res + + +def IfcMlsTotalThickness(layerset): + max = layerset.MaterialLayers[1 - 1].LayerThickness + if sizeof(layerset.MaterialLayers) > 1: + for i in range(2, hiindex(layerset.MaterialLayers) + 1): + max = max + (layerset.MaterialLayers[i - 1].LayerThickness) + return max + + +def IfcNormalise(arg): + + v = IfcDirection(DirectionRatios=[1.,0.]) + vec = IfcVector(Orientation=IfcDirection(DirectionRatios=[1.,0.]), Magnitude=1.) + + result = v + if not exists(arg): + return None + else: + if 'ifc4x3_add1.ifcvector' in typeof(arg): + ndim = arg.Dim + v.DirectionRatios = arg.Orientation.DirectionRatios + vec.Magnitude = arg.Magnitude + vec.Orientation = v + if arg.Magnitude == 0.0: + return None + else: + vec.Magnitude = 1.0 + else: + ndim = arg.Dim + v.DirectionRatios = arg.DirectionRatios + mag = 0.0 + for i in range(1, ndim + 1): + mag = mag + ((v.DirectionRatios[i - 1]) * (v.DirectionRatios[i - 1])) + if mag > 0.0: + mag = sqrt(mag) + for i in range(1, ndim + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = (v.DirectionRatios[i - 1]) / mag + v.DirectionRatios = temp + if 'ifc4x3_add1.ifcvector' in typeof(arg): + vec.Orientation = v + result = vec + else: + result = v + else: + return None + return result + + +def IfcOrthogonalComplement(vec): + + if (not exists(vec)) or (vec.Dim != 2): + return None + else: + result = IfcDirection(DirectionRatios=[-vec.DirectionRatios[2 - 1],vec.DirectionRatios[1 - 1]]) + return result + + +def IfcPathHeadToTail(apath): + n = 0 + p = unknown + n = sizeof(apath.EdgeList) + for i in range(2, n + 1): + p = p and ((apath.EdgeList[i - 1].EdgeEnd) == (apath.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcPointDim(point): + + if 'ifc4x3_add1.ifccartesianpoint' in typeof(point): + return hiindex(point.Coordinates) + if 'ifc4x3_add1.ifcpointbydistanceexpression' in typeof(point): + return point.BasisCurve.Dim + if 'ifc4x3_add1.ifcpointoncurve' in typeof(point): + return point.BasisCurve.Dim + if 'ifc4x3_add1.ifcpointonsurface' in typeof(point): + return point.BasisSurface.Dim + return None + + +def IfcPointListDim(pointlist): + + if 'ifc4x3_add1.ifccartesianpointlist2d' in typeof(pointlist): + return 2 + if 'ifc4x3_add1.ifccartesianpointlist3d' in typeof(pointlist): + return 3 + return None + + +def IfcSameAxis2Placement(ap1, ap2, epsilon): + + return (IfcSameDirection(ap1.P[1 - 1],ap2.P[1 - 1],epsilon)) and (IfcSameDirection(ap1.P[2 - 1],ap2.P[2 - 1],epsilon)) and IfcSameCartesianPoint(ap1.Location,ap2.Location,epsilon) + + +def IfcSameCartesianPoint(cp1, cp2, epsilon): + cp1x = cp1.Coordinates[1 - 1] + cp1y = cp1.Coordinates[2 - 1] + cp1z = 0 + cp2x = cp2.Coordinates[1 - 1] + cp2y = cp2.Coordinates[2 - 1] + cp2z = 0 + if sizeof(cp1.Coordinates) > 2: + cp1z = cp1.Coordinates[3 - 1] + if sizeof(cp2.Coordinates) > 2: + cp2z = cp2.Coordinates[3 - 1] + return IfcSameValue(cp1x,cp2x,epsilon) and IfcSameValue(cp1y,cp2y,epsilon) and IfcSameValue(cp1z,cp2z,epsilon) + + +def IfcSameDirection(dir1, dir2, epsilon): + dir1x = dir1.DirectionRatios[1 - 1] + dir1y = dir1.DirectionRatios[2 - 1] + dir1z = 0 + dir2x = dir2.DirectionRatios[1 - 1] + dir2y = dir2.DirectionRatios[2 - 1] + dir2z = 0 + if sizeof(dir1.DirectionRatios) > 2: + dir1z = dir1.DirectionRatios[3 - 1] + if sizeof(dir2.DirectionRatios) > 2: + dir2z = dir2.DirectionRatios[3 - 1] + return IfcSameValue(dir1x,dir2x,epsilon) and IfcSameValue(dir1y,dir2y,epsilon) and IfcSameValue(dir1z,dir2z,epsilon) + + +def IfcSameValidPrecision(epsilon1, epsilon2): + + defaulteps = 0.000001 + derivationofeps = 1.001 + uppereps = 1.0 + valideps1 = nvl(epsilon1,defaulteps) + valideps2 = nvl(epsilon2,defaulteps) + return (0.0 < valideps1) and (valideps1 <= (derivationofeps * valideps2)) and (valideps2 <= (derivationofeps * valideps1)) and (valideps2 < uppereps) + + +def IfcSameValue(value1, value2, epsilon): + + defaulteps = 0.000001 + valideps = nvl(epsilon,defaulteps) + return ((value1 + valideps) > value2) and (value1 < (value2 + valideps)) + + +def IfcScalarTimesVector(scalar, vec): + + + + if (not exists(scalar)) or (not exists(vec)): + return None + else: + if 'ifc4x3_add1.ifcvector' in typeof(vec): + v = vec.Orientation + mag = scalar * vec.Magnitude + else: + v = vec + mag = scalar + if mag < 0.0: + for i in range(1, sizeof(v.DirectionRatios) + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = -v.DirectionRatios[i - 1] + v.DirectionRatios = temp + mag = -mag + result = IfcVector(Orientation=IfcNormalise(v), Magnitude=mag) + return result + + +def IfcSecondProjAxis(zaxis, xaxis, arg): + + + + if not exists(arg): + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + v = arg + temp = IfcScalarTimesVector(IfcDotProduct(v,zaxis),zaxis) + yaxis = IfcVectorDifference(v,temp) + temp = IfcScalarTimesVector(IfcDotProduct(v,xaxis),xaxis) + yaxis = IfcVectorDifference(yaxis,temp) + yaxis = IfcNormalise(yaxis) + return yaxis.Orientation + + +def IfcSegmentDim(segment): + + if 'ifc4x3_add1.ifccurvesegment' in typeof(segment): + return segment.ParentCurve.Dim + if 'ifc4x3_add1.ifccompositecurvesegment' in typeof(segment): + return segment.ParentCurve.Dim + return None + + +def IfcShapeRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'point': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcpoint' in typeof(temp)]) + elif reptype.lower() == 'pointcloud': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifccartesianpointlist3d' in typeof(temp)]) + elif reptype.lower() == 'curve': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifccurve' in typeof(temp)]) + elif reptype.lower() == 'curve2d': + count = sizeof([temp for temp in items if ('ifc4x3_add1.ifccurve' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'curve3d': + count = sizeof([temp for temp in items if ('ifc4x3_add1.ifccurve' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'segment': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcsegment' in typeof(temp)]) + elif reptype.lower() == 'surface': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcsurface' in typeof(temp)]) + elif reptype.lower() == 'surface2d': + count = sizeof([temp for temp in items if ('ifc4x3_add1.ifcsurface' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'surface3d': + count = sizeof([temp for temp in items if ('ifc4x3_add1.ifcsurface' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'sectionedsurface': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcsectionedsurface' in typeof(temp)]) + elif reptype.lower() == 'fillarea': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcannotationfillarea' in typeof(temp)]) + elif reptype.lower() == 'text': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifctextliteral' in typeof(temp)]) + elif reptype.lower() == 'advancedsurface': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcbsplinesurface' in typeof(temp)]) + elif reptype.lower() == 'annotation2d': + count = sizeof([temp for temp in items if (sizeof(typeof(temp) * ['ifc4x3_add1.ifcpoint','ifc4x3_add1.ifccurve','ifc4x3_add1.ifcgeometriccurveset','ifc4x3_add1.ifcannotationfillarea','ifc4x3_add1.ifctextliteral'])) == 1]) + elif reptype.lower() == 'geometricset': + count = sizeof([temp for temp in items if ('ifc4x3_add1.ifcgeometricset' in typeof(temp)) or ('ifc4x3_add1.ifcpoint' in typeof(temp)) or ('ifc4x3_add1.ifccurve' in typeof(temp)) or ('ifc4x3_add1.ifcsurface' in typeof(temp))]) + elif reptype.lower() == 'geometriccurveset': + count = sizeof([temp for temp in items if ('ifc4x3_add1.ifcgeometriccurveset' in typeof(temp)) or ('ifc4x3_add1.ifcgeometricset' in typeof(temp)) or ('ifc4x3_add1.ifcpoint' in typeof(temp)) or ('ifc4x3_add1.ifccurve' in typeof(temp))]) + for i in range(1, hiindex(items) + 1): + if 'ifc4x3_add1.ifcgeometricset' in (typeof(items[i - 1])): + if (sizeof([temp for temp in items[i - 1].Elements if 'ifc4x3_add1.ifcsurface' in typeof(temp)])) > 0: + count = count - 1 + elif reptype.lower() == 'tessellation': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifctessellateditem' in typeof(temp)]) + elif reptype.lower() == 'surfaceorsolidmodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_add1.ifctessellateditem','ifc4x3_add1.ifcshellbasedsurfacemodel','ifc4x3_add1.ifcfacebasedsurfacemodel','ifc4x3_add1.ifcsolidmodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'surfacemodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_add1.ifctessellateditem','ifc4x3_add1.ifcshellbasedsurfacemodel','ifc4x3_add1.ifcfacebasedsurfacemodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'solidmodel': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcsolidmodel' in typeof(temp)]) + elif reptype.lower() == 'sweptsolid': + count = sizeof([temp for temp in items if ((sizeof(['ifc4x3_add1.ifcextrudedareasolid','ifc4x3_add1.ifcrevolvedareasolid'] * typeof(temp))) >= 1) and ((sizeof(['ifc4x3_add1.ifcextrudedareasolidtapered','ifc4x3_add1.ifcrevolvedareasolidtapered'] * typeof(temp))) == 0)]) + elif reptype.lower() == 'advancedsweptsolid': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_add1.ifcsweptareasolid','ifc4x3_add1.ifcsweptdisksolid','ifc4x3_add1.ifcsectionedsolidhorizontal'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'csg': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_add1.ifcbooleanresult','ifc4x3_add1.ifccsgprimitive3d','ifc4x3_add1.ifccsgsolid'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'clipping': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_add1.ifccsgsolid','ifc4x3_add1.ifcbooleanclippingresult'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'brep': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcfacetedbrep' in typeof(temp)]) + elif reptype.lower() == 'advancedbrep': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcmanifoldsolidbrep' in typeof(temp)]) + elif reptype.lower() == 'boundingbox': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcboundingbox' in typeof(temp)]) + if sizeof(items) > 1: + count = 0 + elif reptype.lower() == 'sectionedspine': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcsectionedspine' in typeof(temp)]) + elif reptype.lower() == 'lightsource': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifclightsource' in typeof(temp)]) + elif reptype.lower() == 'mappedrepresentation': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcmappeditem' in typeof(temp)]) + else: + return None + return count == sizeof(items) + + +def IfcSurfaceWeightsPositive(b): + result = True + weights = b.Weights + for i in range(0, b.UUpper + 1): + for j in range(0, b.VUpper + 1): + if (weights[i - 1][j - 1]) <= 0.0: + result = False + return result + return result + + +def IfcTaperedSweptAreaProfiles(startarea, endarea): + result = False + if 'ifc4x3_add1.ifcparameterizedprofiledef' in typeof(startarea): + if 'ifc4x3_add1.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = typeof(startarea) == typeof(endarea) + else: + if 'ifc4x3_add1.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = False + return result + + +def IfcTopologyRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'vertex': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcvertex' in typeof(temp)]) + elif reptype.lower() == 'edge': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcedge' in typeof(temp)]) + elif reptype.lower() == 'path': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcpath' in typeof(temp)]) + elif reptype.lower() == 'face': + count = sizeof([temp for temp in items if 'ifc4x3_add1.ifcface' in typeof(temp)]) + elif reptype.lower() == 'shell': + count = sizeof([temp for temp in items if ('ifc4x3_add1.ifcopenshell' in typeof(temp)) or ('ifc4x3_add1.ifcclosedshell' in typeof(temp))]) + elif reptype.lower() == 'undefined': + return True + else: + return None + return count == sizeof(items) + + +def IfcUniqueDefinitionNames(relations): + + + properties = express_set([]) + + if sizeof(relations) == 0: + return True + for i in range(1, hiindex(relations) + 1): + definition = relations[i - 1].RelatingPropertyDefinition + if 'ifc4x3_add1.ifcpropertysetdefinition' in typeof(definition): + properties = properties + definition + else: + if 'ifc4x3_add1.ifcpropertysetdefinitionset' in typeof(definition): + definitionset = definition + for j in range(1, hiindex(definitionset) + 1): + properties = properties + (definitionset[j - 1]) + result = IfcUniquePropertySetNames(properties) + return result + + +def IfcUniquePropertyName(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniquePropertySetNames(properties): + names = express_set([]) + unnamed = 0 + for i in range(1, hiindex(properties) + 1): + if 'ifc4x3_add1.ifcpropertyset' in (typeof(properties[i - 1])): + names = names + (properties[i - 1].Name) + else: + unnamed = unnamed + 1 + return (sizeof(names) + unnamed) == sizeof(properties) + + +def IfcUniquePropertyTemplateNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniqueQuantityNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcVectorDifference(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x3_add1.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x3_add1.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) - (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + +def IfcVectorSum(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x3_add1.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x3_add1.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) + (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + diff --git a/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_RC1.py b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_RC1.py new file mode 100644 index 0000000000..93ed5efca6 --- /dev/null +++ b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_RC1.py @@ -0,0 +1,24622 @@ +import ifcopenshell + +def exists(v): + if callable(v): + try: return v() is not None + except IndexError as e: return False + else: return v is not None + + + +def nvl(v, default): return v if v is not None else default + + +sizeof = len +hiindex = len +blength = len +loindex = lambda x: 1 +from math import * +unknown = 'UNKNOWN' + +def usedin(inst, ref_name): + if inst is None: + return [] + _, __, attr = ref_name.split('.') + def filter(): + for ref, attr_idx in inst.wrapped_data.file.get_inverse(inst, allow_duplicate=True, with_attribute_indices=True): + if ref.wrapped_data.get_attribute_names()[attr_idx].lower() == attr: + yield ref + return list(filter()) + + +class express_set(set): + def __rmul__(self, other): + return express_set(set(other) & self) + def __add__(self, other): + def make_list(v): + # Comply with 12.6.3 Union operator + if isinstance(v, (list, tuple, set, express_set)): + return list(v) + else: + return [v] + return express_set(list(self) + make_list(other)) + __radd__ = __add__ + def __repr__(self): + return repr(set(self)) + + +def typeof(inst): + if not inst: + # If V evaluates to indeterminate (?), an empty set is returned. + return express_set([]) + schema_name = inst.is_a(True).split('.')[0].lower() + def inner(): + decl = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(inst.is_a()) + while decl: + yield '.'.join((schema_name, decl.name().lower())) + decl = decl.supertype() + return express_set(inner()) + +class enum_namespace: + def __getattr__(self, k): + return k.upper() + + +IfcActionRequestTypeEnum = enum_namespace() + + +email = IfcActionRequestTypeEnum.EMAIL + + +fax = IfcActionRequestTypeEnum.FAX + + +phone = IfcActionRequestTypeEnum.PHONE + + +post = IfcActionRequestTypeEnum.POST + + +verbal = IfcActionRequestTypeEnum.VERBAL + + +userdefined = IfcActionRequestTypeEnum.USERDEFINED + + +notdefined = IfcActionRequestTypeEnum.NOTDEFINED + + +IfcActionSourceTypeEnum = enum_namespace() + + +dead_load_g = IfcActionSourceTypeEnum.DEAD_LOAD_G + + +completion_g1 = IfcActionSourceTypeEnum.COMPLETION_G1 + + +live_load_q = IfcActionSourceTypeEnum.LIVE_LOAD_Q + + +snow_s = IfcActionSourceTypeEnum.SNOW_S + + +wind_w = IfcActionSourceTypeEnum.WIND_W + + +prestressing_p = IfcActionSourceTypeEnum.PRESTRESSING_P + + +settlement_u = IfcActionSourceTypeEnum.SETTLEMENT_U + + +temperature_t = IfcActionSourceTypeEnum.TEMPERATURE_T + + +earthquake_e = IfcActionSourceTypeEnum.EARTHQUAKE_E + + +fire = IfcActionSourceTypeEnum.FIRE + + +impulse = IfcActionSourceTypeEnum.IMPULSE + + +impact = IfcActionSourceTypeEnum.IMPACT + + +transport = IfcActionSourceTypeEnum.TRANSPORT + + +erection = IfcActionSourceTypeEnum.ERECTION + + +propping = IfcActionSourceTypeEnum.PROPPING + + +system_imperfection = IfcActionSourceTypeEnum.SYSTEM_IMPERFECTION + + +shrinkage = IfcActionSourceTypeEnum.SHRINKAGE + + +creep = IfcActionSourceTypeEnum.CREEP + + +lack_of_fit = IfcActionSourceTypeEnum.LACK_OF_FIT + + +buoyancy = IfcActionSourceTypeEnum.BUOYANCY + + +ice = IfcActionSourceTypeEnum.ICE + + +current = IfcActionSourceTypeEnum.CURRENT + + +wave = IfcActionSourceTypeEnum.WAVE + + +rain = IfcActionSourceTypeEnum.RAIN + + +brakes = IfcActionSourceTypeEnum.BRAKES + + +userdefined = IfcActionSourceTypeEnum.USERDEFINED + + +notdefined = IfcActionSourceTypeEnum.NOTDEFINED + + +IfcActionTypeEnum = enum_namespace() + + +permanent_g = IfcActionTypeEnum.PERMANENT_G + + +variable_q = IfcActionTypeEnum.VARIABLE_Q + + +extraordinary_a = IfcActionTypeEnum.EXTRAORDINARY_A + + +userdefined = IfcActionTypeEnum.USERDEFINED + + +notdefined = IfcActionTypeEnum.NOTDEFINED + + +IfcActuatorTypeEnum = enum_namespace() + + +electricactuator = IfcActuatorTypeEnum.ELECTRICACTUATOR + + +handoperatedactuator = IfcActuatorTypeEnum.HANDOPERATEDACTUATOR + + +hydraulicactuator = IfcActuatorTypeEnum.HYDRAULICACTUATOR + + +pneumaticactuator = IfcActuatorTypeEnum.PNEUMATICACTUATOR + + +thermostaticactuator = IfcActuatorTypeEnum.THERMOSTATICACTUATOR + + +userdefined = IfcActuatorTypeEnum.USERDEFINED + + +notdefined = IfcActuatorTypeEnum.NOTDEFINED + + +IfcAddressTypeEnum = enum_namespace() + + +office = IfcAddressTypeEnum.OFFICE + + +site = IfcAddressTypeEnum.SITE + + +home = IfcAddressTypeEnum.HOME + + +distributionpoint = IfcAddressTypeEnum.DISTRIBUTIONPOINT + + +userdefined = IfcAddressTypeEnum.USERDEFINED + + +IfcAirTerminalBoxTypeEnum = enum_namespace() + + +constantflow = IfcAirTerminalBoxTypeEnum.CONSTANTFLOW + + +variableflowpressuredependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREDEPENDANT + + +variableflowpressureindependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREINDEPENDANT + + +userdefined = IfcAirTerminalBoxTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalBoxTypeEnum.NOTDEFINED + + +IfcAirTerminalTypeEnum = enum_namespace() + + +diffuser = IfcAirTerminalTypeEnum.DIFFUSER + + +grille = IfcAirTerminalTypeEnum.GRILLE + + +louvre = IfcAirTerminalTypeEnum.LOUVRE + + +register = IfcAirTerminalTypeEnum.REGISTER + + +userdefined = IfcAirTerminalTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalTypeEnum.NOTDEFINED + + +IfcAirToAirHeatRecoveryTypeEnum = enum_namespace() + + +fixedplatecounterflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECOUNTERFLOWEXCHANGER + + +fixedplatecrossflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECROSSFLOWEXCHANGER + + +fixedplateparallelflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATEPARALLELFLOWEXCHANGER + + +rotarywheel = IfcAirToAirHeatRecoveryTypeEnum.ROTARYWHEEL + + +runaroundcoilloop = IfcAirToAirHeatRecoveryTypeEnum.RUNAROUNDCOILLOOP + + +heatpipe = IfcAirToAirHeatRecoveryTypeEnum.HEATPIPE + + +twintowerenthalpyrecoveryloops = IfcAirToAirHeatRecoveryTypeEnum.TWINTOWERENTHALPYRECOVERYLOOPS + + +thermosiphonsealedtubeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONSEALEDTUBEHEATEXCHANGERS + + +thermosiphoncoiltypeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONCOILTYPEHEATEXCHANGERS + + +userdefined = IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED + + +notdefined = IfcAirToAirHeatRecoveryTypeEnum.NOTDEFINED + + +IfcAlarmTypeEnum = enum_namespace() + + +bell = IfcAlarmTypeEnum.BELL + + +breakglassbutton = IfcAlarmTypeEnum.BREAKGLASSBUTTON + + +light = IfcAlarmTypeEnum.LIGHT + + +manualpullbox = IfcAlarmTypeEnum.MANUALPULLBOX + + +siren = IfcAlarmTypeEnum.SIREN + + +whistle = IfcAlarmTypeEnum.WHISTLE + + +railwaycrocodile = IfcAlarmTypeEnum.RAILWAYCROCODILE + + +railwaydetonator = IfcAlarmTypeEnum.RAILWAYDETONATOR + + +userdefined = IfcAlarmTypeEnum.USERDEFINED + + +notdefined = IfcAlarmTypeEnum.NOTDEFINED + + +IfcAlignmentTypeEnum = enum_namespace() + + +userdefined = IfcAlignmentTypeEnum.USERDEFINED + + +notdefined = IfcAlignmentTypeEnum.NOTDEFINED + + +IfcAnalysisModelTypeEnum = enum_namespace() + + +in_plane_loading_2d = IfcAnalysisModelTypeEnum.IN_PLANE_LOADING_2D + + +out_plane_loading_2d = IfcAnalysisModelTypeEnum.OUT_PLANE_LOADING_2D + + +loading_3d = IfcAnalysisModelTypeEnum.LOADING_3D + + +userdefined = IfcAnalysisModelTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisModelTypeEnum.NOTDEFINED + + +IfcAnalysisTheoryTypeEnum = enum_namespace() + + +first_order_theory = IfcAnalysisTheoryTypeEnum.FIRST_ORDER_THEORY + + +second_order_theory = IfcAnalysisTheoryTypeEnum.SECOND_ORDER_THEORY + + +third_order_theory = IfcAnalysisTheoryTypeEnum.THIRD_ORDER_THEORY + + +full_nonlinear_theory = IfcAnalysisTheoryTypeEnum.FULL_NONLINEAR_THEORY + + +userdefined = IfcAnalysisTheoryTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisTheoryTypeEnum.NOTDEFINED + + +IfcAnnotationTypeEnum = enum_namespace() + + +assumedpoint = IfcAnnotationTypeEnum.ASSUMEDPOINT + + +asbuiltarea = IfcAnnotationTypeEnum.ASBUILTAREA + + +asbuiltline = IfcAnnotationTypeEnum.ASBUILTLINE + + +non_physical_signal = IfcAnnotationTypeEnum.NON_PHYSICAL_SIGNAL + + +assumedline = IfcAnnotationTypeEnum.ASSUMEDLINE + + +widthevent = IfcAnnotationTypeEnum.WIDTHEVENT + + +assumedarea = IfcAnnotationTypeEnum.ASSUMEDAREA + + +superelevationevent = IfcAnnotationTypeEnum.SUPERELEVATIONEVENT + + +asbuiltpoint = IfcAnnotationTypeEnum.ASBUILTPOINT + + +userdefined = IfcAnnotationTypeEnum.USERDEFINED + + +notdefined = IfcAnnotationTypeEnum.NOTDEFINED + + +IfcArithmeticOperatorEnum = enum_namespace() + + +add = IfcArithmeticOperatorEnum.ADD + + +divide = IfcArithmeticOperatorEnum.DIVIDE + + +multiply = IfcArithmeticOperatorEnum.MULTIPLY + + +subtract = IfcArithmeticOperatorEnum.SUBTRACT + + +IfcAssemblyPlaceEnum = enum_namespace() + + +site = IfcAssemblyPlaceEnum.SITE + + +factory = IfcAssemblyPlaceEnum.FACTORY + + +notdefined = IfcAssemblyPlaceEnum.NOTDEFINED + + +IfcAudioVisualApplianceTypeEnum = enum_namespace() + + +amplifier = IfcAudioVisualApplianceTypeEnum.AMPLIFIER + + +camera = IfcAudioVisualApplianceTypeEnum.CAMERA + + +display = IfcAudioVisualApplianceTypeEnum.DISPLAY + + +microphone = IfcAudioVisualApplianceTypeEnum.MICROPHONE + + +player = IfcAudioVisualApplianceTypeEnum.PLAYER + + +projector = IfcAudioVisualApplianceTypeEnum.PROJECTOR + + +receiver = IfcAudioVisualApplianceTypeEnum.RECEIVER + + +speaker = IfcAudioVisualApplianceTypeEnum.SPEAKER + + +switcher = IfcAudioVisualApplianceTypeEnum.SWITCHER + + +telephone = IfcAudioVisualApplianceTypeEnum.TELEPHONE + + +tuner = IfcAudioVisualApplianceTypeEnum.TUNER + + +railway_communication_terminal = IfcAudioVisualApplianceTypeEnum.RAILWAY_COMMUNICATION_TERMINAL + + +userdefined = IfcAudioVisualApplianceTypeEnum.USERDEFINED + + +notdefined = IfcAudioVisualApplianceTypeEnum.NOTDEFINED + + +IfcBSplineCurveForm = enum_namespace() + + +polyline_form = IfcBSplineCurveForm.POLYLINE_FORM + + +circular_arc = IfcBSplineCurveForm.CIRCULAR_ARC + + +elliptic_arc = IfcBSplineCurveForm.ELLIPTIC_ARC + + +parabolic_arc = IfcBSplineCurveForm.PARABOLIC_ARC + + +hyperbolic_arc = IfcBSplineCurveForm.HYPERBOLIC_ARC + + +unspecified = IfcBSplineCurveForm.UNSPECIFIED + + +IfcBSplineSurfaceForm = enum_namespace() + + +plane_surf = IfcBSplineSurfaceForm.PLANE_SURF + + +cylindrical_surf = IfcBSplineSurfaceForm.CYLINDRICAL_SURF + + +conical_surf = IfcBSplineSurfaceForm.CONICAL_SURF + + +spherical_surf = IfcBSplineSurfaceForm.SPHERICAL_SURF + + +toroidal_surf = IfcBSplineSurfaceForm.TOROIDAL_SURF + + +surf_of_revolution = IfcBSplineSurfaceForm.SURF_OF_REVOLUTION + + +ruled_surf = IfcBSplineSurfaceForm.RULED_SURF + + +generalised_cone = IfcBSplineSurfaceForm.GENERALISED_CONE + + +quadric_surf = IfcBSplineSurfaceForm.QUADRIC_SURF + + +surf_of_linear_extrusion = IfcBSplineSurfaceForm.SURF_OF_LINEAR_EXTRUSION + + +unspecified = IfcBSplineSurfaceForm.UNSPECIFIED + + +IfcBeamTypeEnum = enum_namespace() + + +beam = IfcBeamTypeEnum.BEAM + + +joist = IfcBeamTypeEnum.JOIST + + +hollowcore = IfcBeamTypeEnum.HOLLOWCORE + + +lintel = IfcBeamTypeEnum.LINTEL + + +spandrel = IfcBeamTypeEnum.SPANDREL + + +t_beam = IfcBeamTypeEnum.T_BEAM + + +girder_segment = IfcBeamTypeEnum.GIRDER_SEGMENT + + +diaphragm = IfcBeamTypeEnum.DIAPHRAGM + + +piercap = IfcBeamTypeEnum.PIERCAP + + +hatstone = IfcBeamTypeEnum.HATSTONE + + +cornice = IfcBeamTypeEnum.CORNICE + + +edgebeam = IfcBeamTypeEnum.EDGEBEAM + + +userdefined = IfcBeamTypeEnum.USERDEFINED + + +notdefined = IfcBeamTypeEnum.NOTDEFINED + + +IfcBearingTypeDisplacementEnum = enum_namespace() + + +fixed_movement = IfcBearingTypeDisplacementEnum.FIXED_MOVEMENT + + +guided_longitudinal = IfcBearingTypeDisplacementEnum.GUIDED_LONGITUDINAL + + +guided_transversal = IfcBearingTypeDisplacementEnum.GUIDED_TRANSVERSAL + + +free_movement = IfcBearingTypeDisplacementEnum.FREE_MOVEMENT + + +notdefined = IfcBearingTypeDisplacementEnum.NOTDEFINED + + +IfcBearingTypeEnum = enum_namespace() + + +cylindrical = IfcBearingTypeEnum.CYLINDRICAL + + +spherical = IfcBearingTypeEnum.SPHERICAL + + +elastomeric = IfcBearingTypeEnum.ELASTOMERIC + + +pot = IfcBearingTypeEnum.POT + + +guide = IfcBearingTypeEnum.GUIDE + + +rocker = IfcBearingTypeEnum.ROCKER + + +roller = IfcBearingTypeEnum.ROLLER + + +disk = IfcBearingTypeEnum.DISK + + +userdefined = IfcBearingTypeEnum.USERDEFINED + + +notdefined = IfcBearingTypeEnum.NOTDEFINED + + +IfcBenchmarkEnum = enum_namespace() + + +greaterthan = IfcBenchmarkEnum.GREATERTHAN + + +greaterthanorequalto = IfcBenchmarkEnum.GREATERTHANOREQUALTO + + +lessthan = IfcBenchmarkEnum.LESSTHAN + + +lessthanorequalto = IfcBenchmarkEnum.LESSTHANOREQUALTO + + +equalto = IfcBenchmarkEnum.EQUALTO + + +notequalto = IfcBenchmarkEnum.NOTEQUALTO + + +includes = IfcBenchmarkEnum.INCLUDES + + +notincludes = IfcBenchmarkEnum.NOTINCLUDES + + +includedin = IfcBenchmarkEnum.INCLUDEDIN + + +notincludedin = IfcBenchmarkEnum.NOTINCLUDEDIN + + +IfcBoilerTypeEnum = enum_namespace() + + +water = IfcBoilerTypeEnum.WATER + + +steam = IfcBoilerTypeEnum.STEAM + + +userdefined = IfcBoilerTypeEnum.USERDEFINED + + +notdefined = IfcBoilerTypeEnum.NOTDEFINED + + +IfcBooleanOperator = enum_namespace() + + +union = IfcBooleanOperator.UNION + + +intersection = IfcBooleanOperator.INTERSECTION + + +difference = IfcBooleanOperator.DIFFERENCE + + +IfcBridgePartTypeEnum = enum_namespace() + + +abutment = IfcBridgePartTypeEnum.ABUTMENT + + +deck = IfcBridgePartTypeEnum.DECK + + +deck_segment = IfcBridgePartTypeEnum.DECK_SEGMENT + + +foundation = IfcBridgePartTypeEnum.FOUNDATION + + +pier = IfcBridgePartTypeEnum.PIER + + +pier_segment = IfcBridgePartTypeEnum.PIER_SEGMENT + + +pylon = IfcBridgePartTypeEnum.PYLON + + +substructure = IfcBridgePartTypeEnum.SUBSTRUCTURE + + +superstructure = IfcBridgePartTypeEnum.SUPERSTRUCTURE + + +surfacestructure = IfcBridgePartTypeEnum.SURFACESTRUCTURE + + +userdefined = IfcBridgePartTypeEnum.USERDEFINED + + +notdefined = IfcBridgePartTypeEnum.NOTDEFINED + + +IfcBridgeTypeEnum = enum_namespace() + + +arched = IfcBridgeTypeEnum.ARCHED + + +cable_stayed = IfcBridgeTypeEnum.CABLE_STAYED + + +cantilever = IfcBridgeTypeEnum.CANTILEVER + + +culvert = IfcBridgeTypeEnum.CULVERT + + +framework = IfcBridgeTypeEnum.FRAMEWORK + + +girder = IfcBridgeTypeEnum.GIRDER + + +suspension = IfcBridgeTypeEnum.SUSPENSION + + +truss = IfcBridgeTypeEnum.TRUSS + + +userdefined = IfcBridgeTypeEnum.USERDEFINED + + +notdefined = IfcBridgeTypeEnum.NOTDEFINED + + +IfcBuildingElementPartTypeEnum = enum_namespace() + + +insulation = IfcBuildingElementPartTypeEnum.INSULATION + + +precastpanel = IfcBuildingElementPartTypeEnum.PRECASTPANEL + + +apron = IfcBuildingElementPartTypeEnum.APRON + + +armourunit = IfcBuildingElementPartTypeEnum.ARMOURUNIT + + +safetycage = IfcBuildingElementPartTypeEnum.SAFETYCAGE + + +userdefined = IfcBuildingElementPartTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementPartTypeEnum.NOTDEFINED + + +IfcBuildingElementProxyTypeEnum = enum_namespace() + + +complex = IfcBuildingElementProxyTypeEnum.COMPLEX + + +element = IfcBuildingElementProxyTypeEnum.ELEMENT + + +partial = IfcBuildingElementProxyTypeEnum.PARTIAL + + +provisionforvoid = IfcBuildingElementProxyTypeEnum.PROVISIONFORVOID + + +provisionforspace = IfcBuildingElementProxyTypeEnum.PROVISIONFORSPACE + + +userdefined = IfcBuildingElementProxyTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementProxyTypeEnum.NOTDEFINED + + +IfcBuildingSystemTypeEnum = enum_namespace() + + +fenestration = IfcBuildingSystemTypeEnum.FENESTRATION + + +foundation = IfcBuildingSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuildingSystemTypeEnum.LOADBEARING + + +outershell = IfcBuildingSystemTypeEnum.OUTERSHELL + + +shading = IfcBuildingSystemTypeEnum.SHADING + + +transport = IfcBuildingSystemTypeEnum.TRANSPORT + + +reinforcing = IfcBuildingSystemTypeEnum.REINFORCING + + +prestressing = IfcBuildingSystemTypeEnum.PRESTRESSING + + +erosionprevention = IfcBuildingSystemTypeEnum.EROSIONPREVENTION + + +userdefined = IfcBuildingSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuildingSystemTypeEnum.NOTDEFINED + + +IfcBuiltSystemTypeEnum = enum_namespace() + + +reinforcing = IfcBuiltSystemTypeEnum.REINFORCING + + +mooring = IfcBuiltSystemTypeEnum.MOORING + + +outershell = IfcBuiltSystemTypeEnum.OUTERSHELL + + +trackcircuit = IfcBuiltSystemTypeEnum.TRACKCIRCUIT + + +erosionprevention = IfcBuiltSystemTypeEnum.EROSIONPREVENTION + + +foundation = IfcBuiltSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuiltSystemTypeEnum.LOADBEARING + + +shading = IfcBuiltSystemTypeEnum.SHADING + + +fenestration = IfcBuiltSystemTypeEnum.FENESTRATION + + +mooringsystem = IfcBuiltSystemTypeEnum.MOORINGSYSTEM + + +transport = IfcBuiltSystemTypeEnum.TRANSPORT + + +prestressing = IfcBuiltSystemTypeEnum.PRESTRESSING + + +userdefined = IfcBuiltSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuiltSystemTypeEnum.NOTDEFINED + + +IfcBurnerTypeEnum = enum_namespace() + + +userdefined = IfcBurnerTypeEnum.USERDEFINED + + +notdefined = IfcBurnerTypeEnum.NOTDEFINED + + +IfcCableCarrierFittingTypeEnum = enum_namespace() + + +bend = IfcCableCarrierFittingTypeEnum.BEND + + +cross = IfcCableCarrierFittingTypeEnum.CROSS + + +reducer = IfcCableCarrierFittingTypeEnum.REDUCER + + +tee = IfcCableCarrierFittingTypeEnum.TEE + + +userdefined = IfcCableCarrierFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierFittingTypeEnum.NOTDEFINED + + +IfcCableCarrierSegmentTypeEnum = enum_namespace() + + +cableladdersegment = IfcCableCarrierSegmentTypeEnum.CABLELADDERSEGMENT + + +cabletraysegment = IfcCableCarrierSegmentTypeEnum.CABLETRAYSEGMENT + + +cabletrunkingsegment = IfcCableCarrierSegmentTypeEnum.CABLETRUNKINGSEGMENT + + +conduitsegment = IfcCableCarrierSegmentTypeEnum.CONDUITSEGMENT + + +cablebracket = IfcCableCarrierSegmentTypeEnum.CABLEBRACKET + + +catenarywire = IfcCableCarrierSegmentTypeEnum.CATENARYWIRE + + +dropper = IfcCableCarrierSegmentTypeEnum.DROPPER + + +userdefined = IfcCableCarrierSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierSegmentTypeEnum.NOTDEFINED + + +IfcCableFittingTypeEnum = enum_namespace() + + +connector = IfcCableFittingTypeEnum.CONNECTOR + + +entry = IfcCableFittingTypeEnum.ENTRY + + +exit = IfcCableFittingTypeEnum.EXIT + + +junction = IfcCableFittingTypeEnum.JUNCTION + + +transition = IfcCableFittingTypeEnum.TRANSITION + + +fanout = IfcCableFittingTypeEnum.FANOUT + + +userdefined = IfcCableFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableFittingTypeEnum.NOTDEFINED + + +IfcCableSegmentTypeEnum = enum_namespace() + + +busbarsegment = IfcCableSegmentTypeEnum.BUSBARSEGMENT + + +cablesegment = IfcCableSegmentTypeEnum.CABLESEGMENT + + +conductorsegment = IfcCableSegmentTypeEnum.CONDUCTORSEGMENT + + +coresegment = IfcCableSegmentTypeEnum.CORESEGMENT + + +contactwiresegment = IfcCableSegmentTypeEnum.CONTACTWIRESEGMENT + + +fibersegment = IfcCableSegmentTypeEnum.FIBERSEGMENT + + +fibertube = IfcCableSegmentTypeEnum.FIBERTUBE + + +opticalcablesegment = IfcCableSegmentTypeEnum.OPTICALCABLESEGMENT + + +stitchwire = IfcCableSegmentTypeEnum.STITCHWIRE + + +wirepairsegment = IfcCableSegmentTypeEnum.WIREPAIRSEGMENT + + +userdefined = IfcCableSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableSegmentTypeEnum.NOTDEFINED + + +IfcCaissonFoundationTypeEnum = enum_namespace() + + +well = IfcCaissonFoundationTypeEnum.WELL + + +caisson = IfcCaissonFoundationTypeEnum.CAISSON + + +userdefined = IfcCaissonFoundationTypeEnum.USERDEFINED + + +notdefined = IfcCaissonFoundationTypeEnum.NOTDEFINED + + +IfcChangeActionEnum = enum_namespace() + + +nochange = IfcChangeActionEnum.NOCHANGE + + +modified = IfcChangeActionEnum.MODIFIED + + +added = IfcChangeActionEnum.ADDED + + +deleted = IfcChangeActionEnum.DELETED + + +notdefined = IfcChangeActionEnum.NOTDEFINED + + +IfcChillerTypeEnum = enum_namespace() + + +aircooled = IfcChillerTypeEnum.AIRCOOLED + + +watercooled = IfcChillerTypeEnum.WATERCOOLED + + +heatrecovery = IfcChillerTypeEnum.HEATRECOVERY + + +userdefined = IfcChillerTypeEnum.USERDEFINED + + +notdefined = IfcChillerTypeEnum.NOTDEFINED + + +IfcChimneyTypeEnum = enum_namespace() + + +userdefined = IfcChimneyTypeEnum.USERDEFINED + + +notdefined = IfcChimneyTypeEnum.NOTDEFINED + + +IfcCoilTypeEnum = enum_namespace() + + +dxcoolingcoil = IfcCoilTypeEnum.DXCOOLINGCOIL + + +electricheatingcoil = IfcCoilTypeEnum.ELECTRICHEATINGCOIL + + +gasheatingcoil = IfcCoilTypeEnum.GASHEATINGCOIL + + +hydroniccoil = IfcCoilTypeEnum.HYDRONICCOIL + + +steamheatingcoil = IfcCoilTypeEnum.STEAMHEATINGCOIL + + +watercoolingcoil = IfcCoilTypeEnum.WATERCOOLINGCOIL + + +waterheatingcoil = IfcCoilTypeEnum.WATERHEATINGCOIL + + +userdefined = IfcCoilTypeEnum.USERDEFINED + + +notdefined = IfcCoilTypeEnum.NOTDEFINED + + +IfcColumnTypeEnum = enum_namespace() + + +column = IfcColumnTypeEnum.COLUMN + + +pilaster = IfcColumnTypeEnum.PILASTER + + +pierstem = IfcColumnTypeEnum.PIERSTEM + + +pierstem_segment = IfcColumnTypeEnum.PIERSTEM_SEGMENT + + +standcolumn = IfcColumnTypeEnum.STANDCOLUMN + + +userdefined = IfcColumnTypeEnum.USERDEFINED + + +notdefined = IfcColumnTypeEnum.NOTDEFINED + + +IfcCommunicationsApplianceTypeEnum = enum_namespace() + + +antenna = IfcCommunicationsApplianceTypeEnum.ANTENNA + + +computer = IfcCommunicationsApplianceTypeEnum.COMPUTER + + +fax = IfcCommunicationsApplianceTypeEnum.FAX + + +gateway = IfcCommunicationsApplianceTypeEnum.GATEWAY + + +modem = IfcCommunicationsApplianceTypeEnum.MODEM + + +networkappliance = IfcCommunicationsApplianceTypeEnum.NETWORKAPPLIANCE + + +networkbridge = IfcCommunicationsApplianceTypeEnum.NETWORKBRIDGE + + +networkhub = IfcCommunicationsApplianceTypeEnum.NETWORKHUB + + +printer = IfcCommunicationsApplianceTypeEnum.PRINTER + + +repeater = IfcCommunicationsApplianceTypeEnum.REPEATER + + +router = IfcCommunicationsApplianceTypeEnum.ROUTER + + +scanner = IfcCommunicationsApplianceTypeEnum.SCANNER + + +automaton = IfcCommunicationsApplianceTypeEnum.AUTOMATON + + +intelligent_peripheral = IfcCommunicationsApplianceTypeEnum.INTELLIGENT_PERIPHERAL + + +ip_network_equipment = IfcCommunicationsApplianceTypeEnum.IP_NETWORK_EQUIPMENT + + +optical_network_unit = IfcCommunicationsApplianceTypeEnum.OPTICAL_NETWORK_UNIT + + +telecommand = IfcCommunicationsApplianceTypeEnum.TELECOMMAND + + +telephonyexchange = IfcCommunicationsApplianceTypeEnum.TELEPHONYEXCHANGE + + +transitioncomponent = IfcCommunicationsApplianceTypeEnum.TRANSITIONCOMPONENT + + +transponder = IfcCommunicationsApplianceTypeEnum.TRANSPONDER + + +transportequipment = IfcCommunicationsApplianceTypeEnum.TRANSPORTEQUIPMENT + + +userdefined = IfcCommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcCommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcComplexPropertyTemplateTypeEnum = enum_namespace() + + +p_complex = IfcComplexPropertyTemplateTypeEnum.P_COMPLEX + + +q_complex = IfcComplexPropertyTemplateTypeEnum.Q_COMPLEX + + +IfcCompressorTypeEnum = enum_namespace() + + +dynamic = IfcCompressorTypeEnum.DYNAMIC + + +reciprocating = IfcCompressorTypeEnum.RECIPROCATING + + +rotary = IfcCompressorTypeEnum.ROTARY + + +scroll = IfcCompressorTypeEnum.SCROLL + + +trochoidal = IfcCompressorTypeEnum.TROCHOIDAL + + +singlestage = IfcCompressorTypeEnum.SINGLESTAGE + + +booster = IfcCompressorTypeEnum.BOOSTER + + +opentype = IfcCompressorTypeEnum.OPENTYPE + + +hermetic = IfcCompressorTypeEnum.HERMETIC + + +semihermetic = IfcCompressorTypeEnum.SEMIHERMETIC + + +weldedshellhermetic = IfcCompressorTypeEnum.WELDEDSHELLHERMETIC + + +rollingpiston = IfcCompressorTypeEnum.ROLLINGPISTON + + +rotaryvane = IfcCompressorTypeEnum.ROTARYVANE + + +singlescrew = IfcCompressorTypeEnum.SINGLESCREW + + +twinscrew = IfcCompressorTypeEnum.TWINSCREW + + +userdefined = IfcCompressorTypeEnum.USERDEFINED + + +notdefined = IfcCompressorTypeEnum.NOTDEFINED + + +IfcCondenserTypeEnum = enum_namespace() + + +aircooled = IfcCondenserTypeEnum.AIRCOOLED + + +evaporativecooled = IfcCondenserTypeEnum.EVAPORATIVECOOLED + + +watercooled = IfcCondenserTypeEnum.WATERCOOLED + + +watercooledbrazedplate = IfcCondenserTypeEnum.WATERCOOLEDBRAZEDPLATE + + +watercooledshellcoil = IfcCondenserTypeEnum.WATERCOOLEDSHELLCOIL + + +watercooledshelltube = IfcCondenserTypeEnum.WATERCOOLEDSHELLTUBE + + +watercooledtubeintube = IfcCondenserTypeEnum.WATERCOOLEDTUBEINTUBE + + +userdefined = IfcCondenserTypeEnum.USERDEFINED + + +notdefined = IfcCondenserTypeEnum.NOTDEFINED + + +IfcConnectionTypeEnum = enum_namespace() + + +atpath = IfcConnectionTypeEnum.ATPATH + + +atstart = IfcConnectionTypeEnum.ATSTART + + +atend = IfcConnectionTypeEnum.ATEND + + +notdefined = IfcConnectionTypeEnum.NOTDEFINED + + +IfcConstraintEnum = enum_namespace() + + +hard = IfcConstraintEnum.HARD + + +soft = IfcConstraintEnum.SOFT + + +advisory = IfcConstraintEnum.ADVISORY + + +userdefined = IfcConstraintEnum.USERDEFINED + + +notdefined = IfcConstraintEnum.NOTDEFINED + + +IfcConstructionEquipmentResourceTypeEnum = enum_namespace() + + +demolishing = IfcConstructionEquipmentResourceTypeEnum.DEMOLISHING + + +earthmoving = IfcConstructionEquipmentResourceTypeEnum.EARTHMOVING + + +erecting = IfcConstructionEquipmentResourceTypeEnum.ERECTING + + +heating = IfcConstructionEquipmentResourceTypeEnum.HEATING + + +lighting = IfcConstructionEquipmentResourceTypeEnum.LIGHTING + + +paving = IfcConstructionEquipmentResourceTypeEnum.PAVING + + +pumping = IfcConstructionEquipmentResourceTypeEnum.PUMPING + + +transporting = IfcConstructionEquipmentResourceTypeEnum.TRANSPORTING + + +userdefined = IfcConstructionEquipmentResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionEquipmentResourceTypeEnum.NOTDEFINED + + +IfcConstructionMaterialResourceTypeEnum = enum_namespace() + + +aggregates = IfcConstructionMaterialResourceTypeEnum.AGGREGATES + + +concrete = IfcConstructionMaterialResourceTypeEnum.CONCRETE + + +drywall = IfcConstructionMaterialResourceTypeEnum.DRYWALL + + +fuel = IfcConstructionMaterialResourceTypeEnum.FUEL + + +gypsum = IfcConstructionMaterialResourceTypeEnum.GYPSUM + + +masonry = IfcConstructionMaterialResourceTypeEnum.MASONRY + + +metal = IfcConstructionMaterialResourceTypeEnum.METAL + + +plastic = IfcConstructionMaterialResourceTypeEnum.PLASTIC + + +wood = IfcConstructionMaterialResourceTypeEnum.WOOD + + +notdefined = IfcConstructionMaterialResourceTypeEnum.NOTDEFINED + + +userdefined = IfcConstructionMaterialResourceTypeEnum.USERDEFINED + + +IfcConstructionProductResourceTypeEnum = enum_namespace() + + +assembly = IfcConstructionProductResourceTypeEnum.ASSEMBLY + + +formwork = IfcConstructionProductResourceTypeEnum.FORMWORK + + +userdefined = IfcConstructionProductResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionProductResourceTypeEnum.NOTDEFINED + + +IfcControllerTypeEnum = enum_namespace() + + +floating = IfcControllerTypeEnum.FLOATING + + +programmable = IfcControllerTypeEnum.PROGRAMMABLE + + +proportional = IfcControllerTypeEnum.PROPORTIONAL + + +multiposition = IfcControllerTypeEnum.MULTIPOSITION + + +twoposition = IfcControllerTypeEnum.TWOPOSITION + + +userdefined = IfcControllerTypeEnum.USERDEFINED + + +notdefined = IfcControllerTypeEnum.NOTDEFINED + + +IfcConveyorSegmentTypeEnum = enum_namespace() + + +chuteconveyor = IfcConveyorSegmentTypeEnum.CHUTECONVEYOR + + +beltconveyor = IfcConveyorSegmentTypeEnum.BELTCONVEYOR + + +screwconveyor = IfcConveyorSegmentTypeEnum.SCREWCONVEYOR + + +bucketconveyor = IfcConveyorSegmentTypeEnum.BUCKETCONVEYOR + + +userdefined = IfcConveyorSegmentTypeEnum.USERDEFINED + + +notdefined = IfcConveyorSegmentTypeEnum.NOTDEFINED + + +IfcCooledBeamTypeEnum = enum_namespace() + + +active = IfcCooledBeamTypeEnum.ACTIVE + + +passive = IfcCooledBeamTypeEnum.PASSIVE + + +userdefined = IfcCooledBeamTypeEnum.USERDEFINED + + +notdefined = IfcCooledBeamTypeEnum.NOTDEFINED + + +IfcCoolingTowerTypeEnum = enum_namespace() + + +naturaldraft = IfcCoolingTowerTypeEnum.NATURALDRAFT + + +mechanicalinduceddraft = IfcCoolingTowerTypeEnum.MECHANICALINDUCEDDRAFT + + +mechanicalforceddraft = IfcCoolingTowerTypeEnum.MECHANICALFORCEDDRAFT + + +userdefined = IfcCoolingTowerTypeEnum.USERDEFINED + + +notdefined = IfcCoolingTowerTypeEnum.NOTDEFINED + + +IfcCostItemTypeEnum = enum_namespace() + + +userdefined = IfcCostItemTypeEnum.USERDEFINED + + +notdefined = IfcCostItemTypeEnum.NOTDEFINED + + +IfcCostScheduleTypeEnum = enum_namespace() + + +budget = IfcCostScheduleTypeEnum.BUDGET + + +costplan = IfcCostScheduleTypeEnum.COSTPLAN + + +estimate = IfcCostScheduleTypeEnum.ESTIMATE + + +tender = IfcCostScheduleTypeEnum.TENDER + + +pricedbillofquantities = IfcCostScheduleTypeEnum.PRICEDBILLOFQUANTITIES + + +unpricedbillofquantities = IfcCostScheduleTypeEnum.UNPRICEDBILLOFQUANTITIES + + +scheduleofrates = IfcCostScheduleTypeEnum.SCHEDULEOFRATES + + +userdefined = IfcCostScheduleTypeEnum.USERDEFINED + + +notdefined = IfcCostScheduleTypeEnum.NOTDEFINED + + +IfcCourseTypeEnum = enum_namespace() + + +armour = IfcCourseTypeEnum.ARMOUR + + +filter = IfcCourseTypeEnum.FILTER + + +ballastbed = IfcCourseTypeEnum.BALLASTBED + + +core = IfcCourseTypeEnum.CORE + + +pavement = IfcCourseTypeEnum.PAVEMENT + + +protection = IfcCourseTypeEnum.PROTECTION + + +userdefined = IfcCourseTypeEnum.USERDEFINED + + +notdefined = IfcCourseTypeEnum.NOTDEFINED + + +IfcCoveringTypeEnum = enum_namespace() + + +ceiling = IfcCoveringTypeEnum.CEILING + + +flooring = IfcCoveringTypeEnum.FLOORING + + +cladding = IfcCoveringTypeEnum.CLADDING + + +roofing = IfcCoveringTypeEnum.ROOFING + + +molding = IfcCoveringTypeEnum.MOLDING + + +skirtingboard = IfcCoveringTypeEnum.SKIRTINGBOARD + + +insulation = IfcCoveringTypeEnum.INSULATION + + +membrane = IfcCoveringTypeEnum.MEMBRANE + + +sleeving = IfcCoveringTypeEnum.SLEEVING + + +wrapping = IfcCoveringTypeEnum.WRAPPING + + +coping = IfcCoveringTypeEnum.COPING + + +userdefined = IfcCoveringTypeEnum.USERDEFINED + + +notdefined = IfcCoveringTypeEnum.NOTDEFINED + + +IfcCrewResourceTypeEnum = enum_namespace() + + +office = IfcCrewResourceTypeEnum.OFFICE + + +site = IfcCrewResourceTypeEnum.SITE + + +userdefined = IfcCrewResourceTypeEnum.USERDEFINED + + +notdefined = IfcCrewResourceTypeEnum.NOTDEFINED + + +IfcCurtainWallTypeEnum = enum_namespace() + + +userdefined = IfcCurtainWallTypeEnum.USERDEFINED + + +notdefined = IfcCurtainWallTypeEnum.NOTDEFINED + + +IfcCurveInterpolationEnum = enum_namespace() + + +linear = IfcCurveInterpolationEnum.LINEAR + + +log_linear = IfcCurveInterpolationEnum.LOG_LINEAR + + +log_log = IfcCurveInterpolationEnum.LOG_LOG + + +notdefined = IfcCurveInterpolationEnum.NOTDEFINED + + +IfcDamperTypeEnum = enum_namespace() + + +backdraftdamper = IfcDamperTypeEnum.BACKDRAFTDAMPER + + +balancingdamper = IfcDamperTypeEnum.BALANCINGDAMPER + + +blastdamper = IfcDamperTypeEnum.BLASTDAMPER + + +controldamper = IfcDamperTypeEnum.CONTROLDAMPER + + +firedamper = IfcDamperTypeEnum.FIREDAMPER + + +firesmokedamper = IfcDamperTypeEnum.FIRESMOKEDAMPER + + +fumehoodexhaust = IfcDamperTypeEnum.FUMEHOODEXHAUST + + +gravitydamper = IfcDamperTypeEnum.GRAVITYDAMPER + + +gravityreliefdamper = IfcDamperTypeEnum.GRAVITYRELIEFDAMPER + + +reliefdamper = IfcDamperTypeEnum.RELIEFDAMPER + + +smokedamper = IfcDamperTypeEnum.SMOKEDAMPER + + +userdefined = IfcDamperTypeEnum.USERDEFINED + + +notdefined = IfcDamperTypeEnum.NOTDEFINED + + +IfcDataOriginEnum = enum_namespace() + + +measured = IfcDataOriginEnum.MEASURED + + +predicted = IfcDataOriginEnum.PREDICTED + + +simulated = IfcDataOriginEnum.SIMULATED + + +userdefined = IfcDataOriginEnum.USERDEFINED + + +notdefined = IfcDataOriginEnum.NOTDEFINED + + +IfcDerivedUnitEnum = enum_namespace() + + +angularvelocityunit = IfcDerivedUnitEnum.ANGULARVELOCITYUNIT + + +areadensityunit = IfcDerivedUnitEnum.AREADENSITYUNIT + + +compoundplaneangleunit = IfcDerivedUnitEnum.COMPOUNDPLANEANGLEUNIT + + +dynamicviscosityunit = IfcDerivedUnitEnum.DYNAMICVISCOSITYUNIT + + +heatfluxdensityunit = IfcDerivedUnitEnum.HEATFLUXDENSITYUNIT + + +integercountrateunit = IfcDerivedUnitEnum.INTEGERCOUNTRATEUNIT + + +isothermalmoisturecapacityunit = IfcDerivedUnitEnum.ISOTHERMALMOISTURECAPACITYUNIT + + +kinematicviscosityunit = IfcDerivedUnitEnum.KINEMATICVISCOSITYUNIT + + +linearvelocityunit = IfcDerivedUnitEnum.LINEARVELOCITYUNIT + + +massdensityunit = IfcDerivedUnitEnum.MASSDENSITYUNIT + + +massflowrateunit = IfcDerivedUnitEnum.MASSFLOWRATEUNIT + + +moisturediffusivityunit = IfcDerivedUnitEnum.MOISTUREDIFFUSIVITYUNIT + + +molecularweightunit = IfcDerivedUnitEnum.MOLECULARWEIGHTUNIT + + +specificheatcapacityunit = IfcDerivedUnitEnum.SPECIFICHEATCAPACITYUNIT + + +thermaladmittanceunit = IfcDerivedUnitEnum.THERMALADMITTANCEUNIT + + +thermalconductanceunit = IfcDerivedUnitEnum.THERMALCONDUCTANCEUNIT + + +thermalresistanceunit = IfcDerivedUnitEnum.THERMALRESISTANCEUNIT + + +thermaltransmittanceunit = IfcDerivedUnitEnum.THERMALTRANSMITTANCEUNIT + + +vaporpermeabilityunit = IfcDerivedUnitEnum.VAPORPERMEABILITYUNIT + + +volumetricflowrateunit = IfcDerivedUnitEnum.VOLUMETRICFLOWRATEUNIT + + +rotationalfrequencyunit = IfcDerivedUnitEnum.ROTATIONALFREQUENCYUNIT + + +torqueunit = IfcDerivedUnitEnum.TORQUEUNIT + + +momentofinertiaunit = IfcDerivedUnitEnum.MOMENTOFINERTIAUNIT + + +linearmomentunit = IfcDerivedUnitEnum.LINEARMOMENTUNIT + + +linearforceunit = IfcDerivedUnitEnum.LINEARFORCEUNIT + + +planarforceunit = IfcDerivedUnitEnum.PLANARFORCEUNIT + + +modulusofelasticityunit = IfcDerivedUnitEnum.MODULUSOFELASTICITYUNIT + + +shearmodulusunit = IfcDerivedUnitEnum.SHEARMODULUSUNIT + + +linearstiffnessunit = IfcDerivedUnitEnum.LINEARSTIFFNESSUNIT + + +rotationalstiffnessunit = IfcDerivedUnitEnum.ROTATIONALSTIFFNESSUNIT + + +modulusofsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFSUBGRADEREACTIONUNIT + + +accelerationunit = IfcDerivedUnitEnum.ACCELERATIONUNIT + + +curvatureunit = IfcDerivedUnitEnum.CURVATUREUNIT + + +heatingvalueunit = IfcDerivedUnitEnum.HEATINGVALUEUNIT + + +ionconcentrationunit = IfcDerivedUnitEnum.IONCONCENTRATIONUNIT + + +luminousintensitydistributionunit = IfcDerivedUnitEnum.LUMINOUSINTENSITYDISTRIBUTIONUNIT + + +massperlengthunit = IfcDerivedUnitEnum.MASSPERLENGTHUNIT + + +modulusoflinearsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFLINEARSUBGRADEREACTIONUNIT + + +modulusofrotationalsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFROTATIONALSUBGRADEREACTIONUNIT + + +phunit = IfcDerivedUnitEnum.PHUNIT + + +rotationalmassunit = IfcDerivedUnitEnum.ROTATIONALMASSUNIT + + +sectionareaintegralunit = IfcDerivedUnitEnum.SECTIONAREAINTEGRALUNIT + + +sectionmodulusunit = IfcDerivedUnitEnum.SECTIONMODULUSUNIT + + +soundpowerlevelunit = IfcDerivedUnitEnum.SOUNDPOWERLEVELUNIT + + +soundpowerunit = IfcDerivedUnitEnum.SOUNDPOWERUNIT + + +soundpressurelevelunit = IfcDerivedUnitEnum.SOUNDPRESSURELEVELUNIT + + +soundpressureunit = IfcDerivedUnitEnum.SOUNDPRESSUREUNIT + + +temperaturegradientunit = IfcDerivedUnitEnum.TEMPERATUREGRADIENTUNIT + + +temperaturerateofchangeunit = IfcDerivedUnitEnum.TEMPERATURERATEOFCHANGEUNIT + + +thermalexpansioncoefficientunit = IfcDerivedUnitEnum.THERMALEXPANSIONCOEFFICIENTUNIT + + +warpingconstantunit = IfcDerivedUnitEnum.WARPINGCONSTANTUNIT + + +warpingmomentunit = IfcDerivedUnitEnum.WARPINGMOMENTUNIT + + +userdefined = IfcDerivedUnitEnum.USERDEFINED + + +IfcDirectionSenseEnum = enum_namespace() + + +positive = IfcDirectionSenseEnum.POSITIVE + + +negative = IfcDirectionSenseEnum.NEGATIVE + + +IfcDiscreteAccessoryTypeEnum = enum_namespace() + + +anchorplate = IfcDiscreteAccessoryTypeEnum.ANCHORPLATE + + +bracket = IfcDiscreteAccessoryTypeEnum.BRACKET + + +shoe = IfcDiscreteAccessoryTypeEnum.SHOE + + +expansion_joint_device = IfcDiscreteAccessoryTypeEnum.EXPANSION_JOINT_DEVICE + + +birdprotection = IfcDiscreteAccessoryTypeEnum.BIRDPROTECTION + + +cablearranger = IfcDiscreteAccessoryTypeEnum.CABLEARRANGER + + +insulator = IfcDiscreteAccessoryTypeEnum.INSULATOR + + +lock = IfcDiscreteAccessoryTypeEnum.LOCK + + +tensioningequipment = IfcDiscreteAccessoryTypeEnum.TENSIONINGEQUIPMENT + + +railpad = IfcDiscreteAccessoryTypeEnum.RAILPAD + + +slidingchair = IfcDiscreteAccessoryTypeEnum.SLIDINGCHAIR + + +panel_strengthening = IfcDiscreteAccessoryTypeEnum.PANEL_STRENGTHENING + + +railbrace = IfcDiscreteAccessoryTypeEnum.RAILBRACE + + +elastic_cushion = IfcDiscreteAccessoryTypeEnum.ELASTIC_CUSHION + + +soundabsorption = IfcDiscreteAccessoryTypeEnum.SOUNDABSORPTION + + +rail_lubrication = IfcDiscreteAccessoryTypeEnum.RAIL_LUBRICATION + + +rail_mechanical_equipment = IfcDiscreteAccessoryTypeEnum.RAIL_MECHANICAL_EQUIPMENT + + +userdefined = IfcDiscreteAccessoryTypeEnum.USERDEFINED + + +notdefined = IfcDiscreteAccessoryTypeEnum.NOTDEFINED + + +IfcDistributionBoardTypeEnum = enum_namespace() + + +switchboard = IfcDistributionBoardTypeEnum.SWITCHBOARD + + +consumerunit = IfcDistributionBoardTypeEnum.CONSUMERUNIT + + +motorcontrolcentre = IfcDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +distributionframe = IfcDistributionBoardTypeEnum.DISTRIBUTIONFRAME + + +distributionboard = IfcDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +userdefined = IfcDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcDistributionBoardTypeEnum.NOTDEFINED + + +IfcDistributionChamberElementTypeEnum = enum_namespace() + + +formedduct = IfcDistributionChamberElementTypeEnum.FORMEDDUCT + + +inspectionchamber = IfcDistributionChamberElementTypeEnum.INSPECTIONCHAMBER + + +inspectionpit = IfcDistributionChamberElementTypeEnum.INSPECTIONPIT + + +manhole = IfcDistributionChamberElementTypeEnum.MANHOLE + + +meterchamber = IfcDistributionChamberElementTypeEnum.METERCHAMBER + + +sump = IfcDistributionChamberElementTypeEnum.SUMP + + +trench = IfcDistributionChamberElementTypeEnum.TRENCH + + +valvechamber = IfcDistributionChamberElementTypeEnum.VALVECHAMBER + + +userdefined = IfcDistributionChamberElementTypeEnum.USERDEFINED + + +notdefined = IfcDistributionChamberElementTypeEnum.NOTDEFINED + + +IfcDistributionPortTypeEnum = enum_namespace() + + +cable = IfcDistributionPortTypeEnum.CABLE + + +cablecarrier = IfcDistributionPortTypeEnum.CABLECARRIER + + +duct = IfcDistributionPortTypeEnum.DUCT + + +pipe = IfcDistributionPortTypeEnum.PIPE + + +wireless = IfcDistributionPortTypeEnum.WIRELESS + + +userdefined = IfcDistributionPortTypeEnum.USERDEFINED + + +notdefined = IfcDistributionPortTypeEnum.NOTDEFINED + + +IfcDistributionSystemEnum = enum_namespace() + + +airconditioning = IfcDistributionSystemEnum.AIRCONDITIONING + + +audiovisual = IfcDistributionSystemEnum.AUDIOVISUAL + + +chemical = IfcDistributionSystemEnum.CHEMICAL + + +chilledwater = IfcDistributionSystemEnum.CHILLEDWATER + + +communication = IfcDistributionSystemEnum.COMMUNICATION + + +compressedair = IfcDistributionSystemEnum.COMPRESSEDAIR + + +condenserwater = IfcDistributionSystemEnum.CONDENSERWATER + + +control = IfcDistributionSystemEnum.CONTROL + + +conveying = IfcDistributionSystemEnum.CONVEYING + + +data = IfcDistributionSystemEnum.DATA + + +disposal = IfcDistributionSystemEnum.DISPOSAL + + +domesticcoldwater = IfcDistributionSystemEnum.DOMESTICCOLDWATER + + +domestichotwater = IfcDistributionSystemEnum.DOMESTICHOTWATER + + +drainage = IfcDistributionSystemEnum.DRAINAGE + + +earthing = IfcDistributionSystemEnum.EARTHING + + +electrical = IfcDistributionSystemEnum.ELECTRICAL + + +electroacoustic = IfcDistributionSystemEnum.ELECTROACOUSTIC + + +exhaust = IfcDistributionSystemEnum.EXHAUST + + +fireprotection = IfcDistributionSystemEnum.FIREPROTECTION + + +fuel = IfcDistributionSystemEnum.FUEL + + +gas = IfcDistributionSystemEnum.GAS + + +hazardous = IfcDistributionSystemEnum.HAZARDOUS + + +heating = IfcDistributionSystemEnum.HEATING + + +lighting = IfcDistributionSystemEnum.LIGHTING + + +lightningprotection = IfcDistributionSystemEnum.LIGHTNINGPROTECTION + + +municipalsolidwaste = IfcDistributionSystemEnum.MUNICIPALSOLIDWASTE + + +oil = IfcDistributionSystemEnum.OIL + + +operational = IfcDistributionSystemEnum.OPERATIONAL + + +powergeneration = IfcDistributionSystemEnum.POWERGENERATION + + +rainwater = IfcDistributionSystemEnum.RAINWATER + + +refrigeration = IfcDistributionSystemEnum.REFRIGERATION + + +security = IfcDistributionSystemEnum.SECURITY + + +sewage = IfcDistributionSystemEnum.SEWAGE + + +signal = IfcDistributionSystemEnum.SIGNAL + + +stormwater = IfcDistributionSystemEnum.STORMWATER + + +telephone = IfcDistributionSystemEnum.TELEPHONE + + +tv = IfcDistributionSystemEnum.TV + + +vacuum = IfcDistributionSystemEnum.VACUUM + + +vent = IfcDistributionSystemEnum.VENT + + +ventilation = IfcDistributionSystemEnum.VENTILATION + + +wastewater = IfcDistributionSystemEnum.WASTEWATER + + +watersupply = IfcDistributionSystemEnum.WATERSUPPLY + + +catenary_system = IfcDistributionSystemEnum.CATENARY_SYSTEM + + +overhead_contactline_system = IfcDistributionSystemEnum.OVERHEAD_CONTACTLINE_SYSTEM + + +return_circuit = IfcDistributionSystemEnum.RETURN_CIRCUIT + + +userdefined = IfcDistributionSystemEnum.USERDEFINED + + +notdefined = IfcDistributionSystemEnum.NOTDEFINED + + +IfcDocumentConfidentialityEnum = enum_namespace() + + +public = IfcDocumentConfidentialityEnum.PUBLIC + + +restricted = IfcDocumentConfidentialityEnum.RESTRICTED + + +confidential = IfcDocumentConfidentialityEnum.CONFIDENTIAL + + +personal = IfcDocumentConfidentialityEnum.PERSONAL + + +userdefined = IfcDocumentConfidentialityEnum.USERDEFINED + + +notdefined = IfcDocumentConfidentialityEnum.NOTDEFINED + + +IfcDocumentStatusEnum = enum_namespace() + + +draft = IfcDocumentStatusEnum.DRAFT + + +finaldraft = IfcDocumentStatusEnum.FINALDRAFT + + +final = IfcDocumentStatusEnum.FINAL + + +revision = IfcDocumentStatusEnum.REVISION + + +notdefined = IfcDocumentStatusEnum.NOTDEFINED + + +IfcDoorPanelOperationEnum = enum_namespace() + + +swinging = IfcDoorPanelOperationEnum.SWINGING + + +double_acting = IfcDoorPanelOperationEnum.DOUBLE_ACTING + + +sliding = IfcDoorPanelOperationEnum.SLIDING + + +folding = IfcDoorPanelOperationEnum.FOLDING + + +revolving = IfcDoorPanelOperationEnum.REVOLVING + + +rollingup = IfcDoorPanelOperationEnum.ROLLINGUP + + +fixedpanel = IfcDoorPanelOperationEnum.FIXEDPANEL + + +userdefined = IfcDoorPanelOperationEnum.USERDEFINED + + +notdefined = IfcDoorPanelOperationEnum.NOTDEFINED + + +IfcDoorPanelPositionEnum = enum_namespace() + + +left = IfcDoorPanelPositionEnum.LEFT + + +middle = IfcDoorPanelPositionEnum.MIDDLE + + +right = IfcDoorPanelPositionEnum.RIGHT + + +notdefined = IfcDoorPanelPositionEnum.NOTDEFINED + + +IfcDoorStyleConstructionEnum = enum_namespace() + + +aluminium = IfcDoorStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcDoorStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcDoorStyleConstructionEnum.STEEL + + +wood = IfcDoorStyleConstructionEnum.WOOD + + +aluminium_wood = IfcDoorStyleConstructionEnum.ALUMINIUM_WOOD + + +aluminium_plastic = IfcDoorStyleConstructionEnum.ALUMINIUM_PLASTIC + + +plastic = IfcDoorStyleConstructionEnum.PLASTIC + + +userdefined = IfcDoorStyleConstructionEnum.USERDEFINED + + +notdefined = IfcDoorStyleConstructionEnum.NOTDEFINED + + +IfcDoorStyleOperationEnum = enum_namespace() + + +single_swing_left = IfcDoorStyleOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorStyleOperationEnum.SINGLE_SWING_RIGHT + + +double_door_single_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_swing_left = IfcDoorStyleOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorStyleOperationEnum.DOUBLE_SWING_RIGHT + + +double_door_double_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +sliding_to_left = IfcDoorStyleOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorStyleOperationEnum.SLIDING_TO_RIGHT + + +double_door_sliding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SLIDING + + +folding_to_left = IfcDoorStyleOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorStyleOperationEnum.FOLDING_TO_RIGHT + + +double_door_folding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_FOLDING + + +revolving = IfcDoorStyleOperationEnum.REVOLVING + + +rollingup = IfcDoorStyleOperationEnum.ROLLINGUP + + +userdefined = IfcDoorStyleOperationEnum.USERDEFINED + + +notdefined = IfcDoorStyleOperationEnum.NOTDEFINED + + +IfcDoorTypeEnum = enum_namespace() + + +door = IfcDoorTypeEnum.DOOR + + +gate = IfcDoorTypeEnum.GATE + + +trapdoor = IfcDoorTypeEnum.TRAPDOOR + + +boom_barrier = IfcDoorTypeEnum.BOOM_BARRIER + + +turnstile = IfcDoorTypeEnum.TURNSTILE + + +userdefined = IfcDoorTypeEnum.USERDEFINED + + +notdefined = IfcDoorTypeEnum.NOTDEFINED + + +IfcDoorTypeOperationEnum = enum_namespace() + + +single_swing_left = IfcDoorTypeOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorTypeOperationEnum.SINGLE_SWING_RIGHT + + +double_door_single_swing = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_swing_left = IfcDoorTypeOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorTypeOperationEnum.DOUBLE_SWING_RIGHT + + +double_door_double_swing = IfcDoorTypeOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +sliding_to_left = IfcDoorTypeOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorTypeOperationEnum.SLIDING_TO_RIGHT + + +double_door_sliding = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SLIDING + + +folding_to_left = IfcDoorTypeOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorTypeOperationEnum.FOLDING_TO_RIGHT + + +double_door_folding = IfcDoorTypeOperationEnum.DOUBLE_DOOR_FOLDING + + +revolving = IfcDoorTypeOperationEnum.REVOLVING + + +rollingup = IfcDoorTypeOperationEnum.ROLLINGUP + + +swing_fixed_left = IfcDoorTypeOperationEnum.SWING_FIXED_LEFT + + +swing_fixed_right = IfcDoorTypeOperationEnum.SWING_FIXED_RIGHT + + +userdefined = IfcDoorTypeOperationEnum.USERDEFINED + + +notdefined = IfcDoorTypeOperationEnum.NOTDEFINED + + +IfcDuctFittingTypeEnum = enum_namespace() + + +bend = IfcDuctFittingTypeEnum.BEND + + +connector = IfcDuctFittingTypeEnum.CONNECTOR + + +entry = IfcDuctFittingTypeEnum.ENTRY + + +exit = IfcDuctFittingTypeEnum.EXIT + + +junction = IfcDuctFittingTypeEnum.JUNCTION + + +obstruction = IfcDuctFittingTypeEnum.OBSTRUCTION + + +transition = IfcDuctFittingTypeEnum.TRANSITION + + +userdefined = IfcDuctFittingTypeEnum.USERDEFINED + + +notdefined = IfcDuctFittingTypeEnum.NOTDEFINED + + +IfcDuctSegmentTypeEnum = enum_namespace() + + +rigidsegment = IfcDuctSegmentTypeEnum.RIGIDSEGMENT + + +flexiblesegment = IfcDuctSegmentTypeEnum.FLEXIBLESEGMENT + + +userdefined = IfcDuctSegmentTypeEnum.USERDEFINED + + +notdefined = IfcDuctSegmentTypeEnum.NOTDEFINED + + +IfcDuctSilencerTypeEnum = enum_namespace() + + +flatoval = IfcDuctSilencerTypeEnum.FLATOVAL + + +rectangular = IfcDuctSilencerTypeEnum.RECTANGULAR + + +round = IfcDuctSilencerTypeEnum.ROUND + + +userdefined = IfcDuctSilencerTypeEnum.USERDEFINED + + +notdefined = IfcDuctSilencerTypeEnum.NOTDEFINED + + +IfcEarthworksCutTypeEnum = enum_namespace() + + +trench = IfcEarthworksCutTypeEnum.TRENCH + + +dredging = IfcEarthworksCutTypeEnum.DREDGING + + +excavation = IfcEarthworksCutTypeEnum.EXCAVATION + + +overexcavation = IfcEarthworksCutTypeEnum.OVEREXCAVATION + + +topsoilremoval = IfcEarthworksCutTypeEnum.TOPSOILREMOVAL + + +stepexcavation = IfcEarthworksCutTypeEnum.STEPEXCAVATION + + +pavementmilling = IfcEarthworksCutTypeEnum.PAVEMENTMILLING + + +cut = IfcEarthworksCutTypeEnum.CUT + + +base_excavation = IfcEarthworksCutTypeEnum.BASE_EXCAVATION + + +userdefined = IfcEarthworksCutTypeEnum.USERDEFINED + + +notdefined = IfcEarthworksCutTypeEnum.NOTDEFINED + + +IfcEarthworksFillTypeEnum = enum_namespace() + + +backfill = IfcEarthworksFillTypeEnum.BACKFILL + + +counterweight = IfcEarthworksFillTypeEnum.COUNTERWEIGHT + + +subgrade = IfcEarthworksFillTypeEnum.SUBGRADE + + +embankment = IfcEarthworksFillTypeEnum.EMBANKMENT + + +transitionsection = IfcEarthworksFillTypeEnum.TRANSITIONSECTION + + +subgradebed = IfcEarthworksFillTypeEnum.SUBGRADEBED + + +slopefill = IfcEarthworksFillTypeEnum.SLOPEFILL + + +userdefined = IfcEarthworksFillTypeEnum.USERDEFINED + + +notdefined = IfcEarthworksFillTypeEnum.NOTDEFINED + + +IfcElectricApplianceTypeEnum = enum_namespace() + + +dishwasher = IfcElectricApplianceTypeEnum.DISHWASHER + + +electriccooker = IfcElectricApplianceTypeEnum.ELECTRICCOOKER + + +freestandingelectricheater = IfcElectricApplianceTypeEnum.FREESTANDINGELECTRICHEATER + + +freestandingfan = IfcElectricApplianceTypeEnum.FREESTANDINGFAN + + +freestandingwaterheater = IfcElectricApplianceTypeEnum.FREESTANDINGWATERHEATER + + +freestandingwatercooler = IfcElectricApplianceTypeEnum.FREESTANDINGWATERCOOLER + + +freezer = IfcElectricApplianceTypeEnum.FREEZER + + +fridge_freezer = IfcElectricApplianceTypeEnum.FRIDGE_FREEZER + + +handdryer = IfcElectricApplianceTypeEnum.HANDDRYER + + +kitchenmachine = IfcElectricApplianceTypeEnum.KITCHENMACHINE + + +microwave = IfcElectricApplianceTypeEnum.MICROWAVE + + +photocopier = IfcElectricApplianceTypeEnum.PHOTOCOPIER + + +refrigerator = IfcElectricApplianceTypeEnum.REFRIGERATOR + + +tumbledryer = IfcElectricApplianceTypeEnum.TUMBLEDRYER + + +vendingmachine = IfcElectricApplianceTypeEnum.VENDINGMACHINE + + +washingmachine = IfcElectricApplianceTypeEnum.WASHINGMACHINE + + +userdefined = IfcElectricApplianceTypeEnum.USERDEFINED + + +notdefined = IfcElectricApplianceTypeEnum.NOTDEFINED + + +IfcElectricDistributionBoardTypeEnum = enum_namespace() + + +consumerunit = IfcElectricDistributionBoardTypeEnum.CONSUMERUNIT + + +distributionboard = IfcElectricDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +motorcontrolcentre = IfcElectricDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +switchboard = IfcElectricDistributionBoardTypeEnum.SWITCHBOARD + + +userdefined = IfcElectricDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcElectricDistributionBoardTypeEnum.NOTDEFINED + + +IfcElectricFlowStorageDeviceTypeEnum = enum_namespace() + + +battery = IfcElectricFlowStorageDeviceTypeEnum.BATTERY + + +capacitorbank = IfcElectricFlowStorageDeviceTypeEnum.CAPACITORBANK + + +harmonicfilter = IfcElectricFlowStorageDeviceTypeEnum.HARMONICFILTER + + +inductorbank = IfcElectricFlowStorageDeviceTypeEnum.INDUCTORBANK + + +ups = IfcElectricFlowStorageDeviceTypeEnum.UPS + + +capacitor = IfcElectricFlowStorageDeviceTypeEnum.CAPACITOR + + +compensator = IfcElectricFlowStorageDeviceTypeEnum.COMPENSATOR + + +inductor = IfcElectricFlowStorageDeviceTypeEnum.INDUCTOR + + +recharger = IfcElectricFlowStorageDeviceTypeEnum.RECHARGER + + +userdefined = IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowStorageDeviceTypeEnum.NOTDEFINED + + +IfcElectricFlowTreatmentDeviceTypeEnum = enum_namespace() + + +electronicfilter = IfcElectricFlowTreatmentDeviceTypeEnum.ELECTRONICFILTER + + +userdefined = IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowTreatmentDeviceTypeEnum.NOTDEFINED + + +IfcElectricGeneratorTypeEnum = enum_namespace() + + +chp = IfcElectricGeneratorTypeEnum.CHP + + +enginegenerator = IfcElectricGeneratorTypeEnum.ENGINEGENERATOR + + +standalone = IfcElectricGeneratorTypeEnum.STANDALONE + + +userdefined = IfcElectricGeneratorTypeEnum.USERDEFINED + + +notdefined = IfcElectricGeneratorTypeEnum.NOTDEFINED + + +IfcElectricMotorTypeEnum = enum_namespace() + + +dc = IfcElectricMotorTypeEnum.DC + + +induction = IfcElectricMotorTypeEnum.INDUCTION + + +polyphase = IfcElectricMotorTypeEnum.POLYPHASE + + +reluctancesynchronous = IfcElectricMotorTypeEnum.RELUCTANCESYNCHRONOUS + + +synchronous = IfcElectricMotorTypeEnum.SYNCHRONOUS + + +userdefined = IfcElectricMotorTypeEnum.USERDEFINED + + +notdefined = IfcElectricMotorTypeEnum.NOTDEFINED + + +IfcElectricTimeControlTypeEnum = enum_namespace() + + +timeclock = IfcElectricTimeControlTypeEnum.TIMECLOCK + + +timedelay = IfcElectricTimeControlTypeEnum.TIMEDELAY + + +relay = IfcElectricTimeControlTypeEnum.RELAY + + +userdefined = IfcElectricTimeControlTypeEnum.USERDEFINED + + +notdefined = IfcElectricTimeControlTypeEnum.NOTDEFINED + + +IfcElementAssemblyTypeEnum = enum_namespace() + + +accessory_assembly = IfcElementAssemblyTypeEnum.ACCESSORY_ASSEMBLY + + +arch = IfcElementAssemblyTypeEnum.ARCH + + +beam_grid = IfcElementAssemblyTypeEnum.BEAM_GRID + + +braced_frame = IfcElementAssemblyTypeEnum.BRACED_FRAME + + +girder = IfcElementAssemblyTypeEnum.GIRDER + + +reinforcement_unit = IfcElementAssemblyTypeEnum.REINFORCEMENT_UNIT + + +rigid_frame = IfcElementAssemblyTypeEnum.RIGID_FRAME + + +slab_field = IfcElementAssemblyTypeEnum.SLAB_FIELD + + +truss = IfcElementAssemblyTypeEnum.TRUSS + + +abutment = IfcElementAssemblyTypeEnum.ABUTMENT + + +pier = IfcElementAssemblyTypeEnum.PIER + + +pylon = IfcElementAssemblyTypeEnum.PYLON + + +cross_bracing = IfcElementAssemblyTypeEnum.CROSS_BRACING + + +deck = IfcElementAssemblyTypeEnum.DECK + + +mast = IfcElementAssemblyTypeEnum.MAST + + +signalassembly = IfcElementAssemblyTypeEnum.SIGNALASSEMBLY + + +grid = IfcElementAssemblyTypeEnum.GRID + + +shelter = IfcElementAssemblyTypeEnum.SHELTER + + +supportingassembly = IfcElementAssemblyTypeEnum.SUPPORTINGASSEMBLY + + +suspensionassembly = IfcElementAssemblyTypeEnum.SUSPENSIONASSEMBLY + + +traction_switching_assembly = IfcElementAssemblyTypeEnum.TRACTION_SWITCHING_ASSEMBLY + + +trackpanel = IfcElementAssemblyTypeEnum.TRACKPANEL + + +turnoutpanel = IfcElementAssemblyTypeEnum.TURNOUTPANEL + + +dilatationpanel = IfcElementAssemblyTypeEnum.DILATATIONPANEL + + +rail_mechanical_equipment_assembly = IfcElementAssemblyTypeEnum.RAIL_MECHANICAL_EQUIPMENT_ASSEMBLY + + +entranceworks = IfcElementAssemblyTypeEnum.ENTRANCEWORKS + + +sumpbuster = IfcElementAssemblyTypeEnum.SUMPBUSTER + + +traffic_calming_device = IfcElementAssemblyTypeEnum.TRAFFIC_CALMING_DEVICE + + +userdefined = IfcElementAssemblyTypeEnum.USERDEFINED + + +notdefined = IfcElementAssemblyTypeEnum.NOTDEFINED + + +IfcElementCompositionEnum = enum_namespace() + + +complex = IfcElementCompositionEnum.COMPLEX + + +element = IfcElementCompositionEnum.ELEMENT + + +partial = IfcElementCompositionEnum.PARTIAL + + +IfcEngineTypeEnum = enum_namespace() + + +externalcombustion = IfcEngineTypeEnum.EXTERNALCOMBUSTION + + +internalcombustion = IfcEngineTypeEnum.INTERNALCOMBUSTION + + +userdefined = IfcEngineTypeEnum.USERDEFINED + + +notdefined = IfcEngineTypeEnum.NOTDEFINED + + +IfcEvaporativeCoolerTypeEnum = enum_namespace() + + +directevaporativerandommediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER + + +directevaporativerigidmediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER + + +directevaporativeslingerspackagedaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER + + +directevaporativepackagedrotaryaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER + + +directevaporativeairwasher = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEAIRWASHER + + +indirectevaporativepackageaircooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEPACKAGEAIRCOOLER + + +indirectevaporativewetcoil = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEWETCOIL + + +indirectevaporativecoolingtowerorcoilcooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER + + +indirectdirectcombination = IfcEvaporativeCoolerTypeEnum.INDIRECTDIRECTCOMBINATION + + +userdefined = IfcEvaporativeCoolerTypeEnum.USERDEFINED + + +notdefined = IfcEvaporativeCoolerTypeEnum.NOTDEFINED + + +IfcEvaporatorTypeEnum = enum_namespace() + + +directexpansion = IfcEvaporatorTypeEnum.DIRECTEXPANSION + + +directexpansionshellandtube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONSHELLANDTUBE + + +directexpansiontubeintube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONTUBEINTUBE + + +directexpansionbrazedplate = IfcEvaporatorTypeEnum.DIRECTEXPANSIONBRAZEDPLATE + + +floodedshellandtube = IfcEvaporatorTypeEnum.FLOODEDSHELLANDTUBE + + +shellandcoil = IfcEvaporatorTypeEnum.SHELLANDCOIL + + +userdefined = IfcEvaporatorTypeEnum.USERDEFINED + + +notdefined = IfcEvaporatorTypeEnum.NOTDEFINED + + +IfcEventTriggerTypeEnum = enum_namespace() + + +eventrule = IfcEventTriggerTypeEnum.EVENTRULE + + +eventmessage = IfcEventTriggerTypeEnum.EVENTMESSAGE + + +eventtime = IfcEventTriggerTypeEnum.EVENTTIME + + +eventcomplex = IfcEventTriggerTypeEnum.EVENTCOMPLEX + + +userdefined = IfcEventTriggerTypeEnum.USERDEFINED + + +notdefined = IfcEventTriggerTypeEnum.NOTDEFINED + + +IfcEventTypeEnum = enum_namespace() + + +startevent = IfcEventTypeEnum.STARTEVENT + + +endevent = IfcEventTypeEnum.ENDEVENT + + +intermediateevent = IfcEventTypeEnum.INTERMEDIATEEVENT + + +userdefined = IfcEventTypeEnum.USERDEFINED + + +notdefined = IfcEventTypeEnum.NOTDEFINED + + +IfcExternalSpatialElementTypeEnum = enum_namespace() + + +external = IfcExternalSpatialElementTypeEnum.EXTERNAL + + +external_earth = IfcExternalSpatialElementTypeEnum.EXTERNAL_EARTH + + +external_water = IfcExternalSpatialElementTypeEnum.EXTERNAL_WATER + + +external_fire = IfcExternalSpatialElementTypeEnum.EXTERNAL_FIRE + + +userdefined = IfcExternalSpatialElementTypeEnum.USERDEFINED + + +notdefined = IfcExternalSpatialElementTypeEnum.NOTDEFINED + + +IfcFacilityPartCommonTypeEnum = enum_namespace() + + +segment = IfcFacilityPartCommonTypeEnum.SEGMENT + + +aboveground = IfcFacilityPartCommonTypeEnum.ABOVEGROUND + + +junction = IfcFacilityPartCommonTypeEnum.JUNCTION + + +levelcrossing = IfcFacilityPartCommonTypeEnum.LEVELCROSSING + + +belowground = IfcFacilityPartCommonTypeEnum.BELOWGROUND + + +substructure = IfcFacilityPartCommonTypeEnum.SUBSTRUCTURE + + +terminal = IfcFacilityPartCommonTypeEnum.TERMINAL + + +superstructure = IfcFacilityPartCommonTypeEnum.SUPERSTRUCTURE + + +userdefined = IfcFacilityPartCommonTypeEnum.USERDEFINED + + +notdefined = IfcFacilityPartCommonTypeEnum.NOTDEFINED + + +IfcFacilityUsageEnum = enum_namespace() + + +lateral = IfcFacilityUsageEnum.LATERAL + + +region = IfcFacilityUsageEnum.REGION + + +vertical = IfcFacilityUsageEnum.VERTICAL + + +longitudinal = IfcFacilityUsageEnum.LONGITUDINAL + + +userdefined = IfcFacilityUsageEnum.USERDEFINED + + +notdefined = IfcFacilityUsageEnum.NOTDEFINED + + +IfcFanTypeEnum = enum_namespace() + + +centrifugalforwardcurved = IfcFanTypeEnum.CENTRIFUGALFORWARDCURVED + + +centrifugalradial = IfcFanTypeEnum.CENTRIFUGALRADIAL + + +centrifugalbackwardinclinedcurved = IfcFanTypeEnum.CENTRIFUGALBACKWARDINCLINEDCURVED + + +centrifugalairfoil = IfcFanTypeEnum.CENTRIFUGALAIRFOIL + + +tubeaxial = IfcFanTypeEnum.TUBEAXIAL + + +vaneaxial = IfcFanTypeEnum.VANEAXIAL + + +propelloraxial = IfcFanTypeEnum.PROPELLORAXIAL + + +userdefined = IfcFanTypeEnum.USERDEFINED + + +notdefined = IfcFanTypeEnum.NOTDEFINED + + +IfcFastenerTypeEnum = enum_namespace() + + +glue = IfcFastenerTypeEnum.GLUE + + +mortar = IfcFastenerTypeEnum.MORTAR + + +weld = IfcFastenerTypeEnum.WELD + + +userdefined = IfcFastenerTypeEnum.USERDEFINED + + +notdefined = IfcFastenerTypeEnum.NOTDEFINED + + +IfcFilterTypeEnum = enum_namespace() + + +airparticlefilter = IfcFilterTypeEnum.AIRPARTICLEFILTER + + +compressedairfilter = IfcFilterTypeEnum.COMPRESSEDAIRFILTER + + +odorfilter = IfcFilterTypeEnum.ODORFILTER + + +oilfilter = IfcFilterTypeEnum.OILFILTER + + +strainer = IfcFilterTypeEnum.STRAINER + + +waterfilter = IfcFilterTypeEnum.WATERFILTER + + +userdefined = IfcFilterTypeEnum.USERDEFINED + + +notdefined = IfcFilterTypeEnum.NOTDEFINED + + +IfcFireSuppressionTerminalTypeEnum = enum_namespace() + + +breechinginlet = IfcFireSuppressionTerminalTypeEnum.BREECHINGINLET + + +firehydrant = IfcFireSuppressionTerminalTypeEnum.FIREHYDRANT + + +hosereel = IfcFireSuppressionTerminalTypeEnum.HOSEREEL + + +sprinkler = IfcFireSuppressionTerminalTypeEnum.SPRINKLER + + +sprinklerdeflector = IfcFireSuppressionTerminalTypeEnum.SPRINKLERDEFLECTOR + + +userdefined = IfcFireSuppressionTerminalTypeEnum.USERDEFINED + + +notdefined = IfcFireSuppressionTerminalTypeEnum.NOTDEFINED + + +IfcFlowDirectionEnum = enum_namespace() + + +source = IfcFlowDirectionEnum.SOURCE + + +sink = IfcFlowDirectionEnum.SINK + + +sourceandsink = IfcFlowDirectionEnum.SOURCEANDSINK + + +notdefined = IfcFlowDirectionEnum.NOTDEFINED + + +IfcFlowInstrumentTypeEnum = enum_namespace() + + +pressuregauge = IfcFlowInstrumentTypeEnum.PRESSUREGAUGE + + +thermometer = IfcFlowInstrumentTypeEnum.THERMOMETER + + +ammeter = IfcFlowInstrumentTypeEnum.AMMETER + + +frequencymeter = IfcFlowInstrumentTypeEnum.FREQUENCYMETER + + +powerfactormeter = IfcFlowInstrumentTypeEnum.POWERFACTORMETER + + +phaseanglemeter = IfcFlowInstrumentTypeEnum.PHASEANGLEMETER + + +voltmeter_peak = IfcFlowInstrumentTypeEnum.VOLTMETER_PEAK + + +voltmeter_rms = IfcFlowInstrumentTypeEnum.VOLTMETER_RMS + + +combined = IfcFlowInstrumentTypeEnum.COMBINED + + +voltmeter = IfcFlowInstrumentTypeEnum.VOLTMETER + + +userdefined = IfcFlowInstrumentTypeEnum.USERDEFINED + + +notdefined = IfcFlowInstrumentTypeEnum.NOTDEFINED + + +IfcFlowMeterTypeEnum = enum_namespace() + + +energymeter = IfcFlowMeterTypeEnum.ENERGYMETER + + +gasmeter = IfcFlowMeterTypeEnum.GASMETER + + +oilmeter = IfcFlowMeterTypeEnum.OILMETER + + +watermeter = IfcFlowMeterTypeEnum.WATERMETER + + +userdefined = IfcFlowMeterTypeEnum.USERDEFINED + + +notdefined = IfcFlowMeterTypeEnum.NOTDEFINED + + +IfcFootingTypeEnum = enum_namespace() + + +caisson_foundation = IfcFootingTypeEnum.CAISSON_FOUNDATION + + +footing_beam = IfcFootingTypeEnum.FOOTING_BEAM + + +pad_footing = IfcFootingTypeEnum.PAD_FOOTING + + +pile_cap = IfcFootingTypeEnum.PILE_CAP + + +strip_footing = IfcFootingTypeEnum.STRIP_FOOTING + + +userdefined = IfcFootingTypeEnum.USERDEFINED + + +notdefined = IfcFootingTypeEnum.NOTDEFINED + + +IfcFurnitureTypeEnum = enum_namespace() + + +chair = IfcFurnitureTypeEnum.CHAIR + + +table = IfcFurnitureTypeEnum.TABLE + + +desk = IfcFurnitureTypeEnum.DESK + + +bed = IfcFurnitureTypeEnum.BED + + +filecabinet = IfcFurnitureTypeEnum.FILECABINET + + +shelf = IfcFurnitureTypeEnum.SHELF + + +sofa = IfcFurnitureTypeEnum.SOFA + + +technicalcabinet = IfcFurnitureTypeEnum.TECHNICALCABINET + + +userdefined = IfcFurnitureTypeEnum.USERDEFINED + + +notdefined = IfcFurnitureTypeEnum.NOTDEFINED + + +IfcGeographicElementTypeEnum = enum_namespace() + + +terrain = IfcGeographicElementTypeEnum.TERRAIN + + +soil_boring_point = IfcGeographicElementTypeEnum.SOIL_BORING_POINT + + +userdefined = IfcGeographicElementTypeEnum.USERDEFINED + + +notdefined = IfcGeographicElementTypeEnum.NOTDEFINED + + +IfcGeometricProjectionEnum = enum_namespace() + + +graph_view = IfcGeometricProjectionEnum.GRAPH_VIEW + + +sketch_view = IfcGeometricProjectionEnum.SKETCH_VIEW + + +model_view = IfcGeometricProjectionEnum.MODEL_VIEW + + +plan_view = IfcGeometricProjectionEnum.PLAN_VIEW + + +reflected_plan_view = IfcGeometricProjectionEnum.REFLECTED_PLAN_VIEW + + +section_view = IfcGeometricProjectionEnum.SECTION_VIEW + + +elevation_view = IfcGeometricProjectionEnum.ELEVATION_VIEW + + +userdefined = IfcGeometricProjectionEnum.USERDEFINED + + +notdefined = IfcGeometricProjectionEnum.NOTDEFINED + + +IfcGlobalOrLocalEnum = enum_namespace() + + +global_coords = IfcGlobalOrLocalEnum.GLOBAL_COORDS + + +local_coords = IfcGlobalOrLocalEnum.LOCAL_COORDS + + +IfcGridTypeEnum = enum_namespace() + + +rectangular = IfcGridTypeEnum.RECTANGULAR + + +radial = IfcGridTypeEnum.RADIAL + + +triangular = IfcGridTypeEnum.TRIANGULAR + + +irregular = IfcGridTypeEnum.IRREGULAR + + +userdefined = IfcGridTypeEnum.USERDEFINED + + +notdefined = IfcGridTypeEnum.NOTDEFINED + + +IfcHeatExchangerTypeEnum = enum_namespace() + + +plate = IfcHeatExchangerTypeEnum.PLATE + + +shellandtube = IfcHeatExchangerTypeEnum.SHELLANDTUBE + + +turnoutheating = IfcHeatExchangerTypeEnum.TURNOUTHEATING + + +userdefined = IfcHeatExchangerTypeEnum.USERDEFINED + + +notdefined = IfcHeatExchangerTypeEnum.NOTDEFINED + + +IfcHumidifierTypeEnum = enum_namespace() + + +steaminjection = IfcHumidifierTypeEnum.STEAMINJECTION + + +adiabaticairwasher = IfcHumidifierTypeEnum.ADIABATICAIRWASHER + + +adiabaticpan = IfcHumidifierTypeEnum.ADIABATICPAN + + +adiabaticwettedelement = IfcHumidifierTypeEnum.ADIABATICWETTEDELEMENT + + +adiabaticatomizing = IfcHumidifierTypeEnum.ADIABATICATOMIZING + + +adiabaticultrasonic = IfcHumidifierTypeEnum.ADIABATICULTRASONIC + + +adiabaticrigidmedia = IfcHumidifierTypeEnum.ADIABATICRIGIDMEDIA + + +adiabaticcompressedairnozzle = IfcHumidifierTypeEnum.ADIABATICCOMPRESSEDAIRNOZZLE + + +assistedelectric = IfcHumidifierTypeEnum.ASSISTEDELECTRIC + + +assistednaturalgas = IfcHumidifierTypeEnum.ASSISTEDNATURALGAS + + +assistedpropane = IfcHumidifierTypeEnum.ASSISTEDPROPANE + + +assistedbutane = IfcHumidifierTypeEnum.ASSISTEDBUTANE + + +assistedsteam = IfcHumidifierTypeEnum.ASSISTEDSTEAM + + +userdefined = IfcHumidifierTypeEnum.USERDEFINED + + +notdefined = IfcHumidifierTypeEnum.NOTDEFINED + + +IfcImpactProtectionDeviceTypeEnum = enum_namespace() + + +crashcushion = IfcImpactProtectionDeviceTypeEnum.CRASHCUSHION + + +dampingsystem = IfcImpactProtectionDeviceTypeEnum.DAMPINGSYSTEM + + +fender = IfcImpactProtectionDeviceTypeEnum.FENDER + + +bumper = IfcImpactProtectionDeviceTypeEnum.BUMPER + + +userdefined = IfcImpactProtectionDeviceTypeEnum.USERDEFINED + + +notdefined = IfcImpactProtectionDeviceTypeEnum.NOTDEFINED + + +IfcInterceptorTypeEnum = enum_namespace() + + +cyclonic = IfcInterceptorTypeEnum.CYCLONIC + + +grease = IfcInterceptorTypeEnum.GREASE + + +oil = IfcInterceptorTypeEnum.OIL + + +petrol = IfcInterceptorTypeEnum.PETROL + + +userdefined = IfcInterceptorTypeEnum.USERDEFINED + + +notdefined = IfcInterceptorTypeEnum.NOTDEFINED + + +IfcInternalOrExternalEnum = enum_namespace() + + +internal = IfcInternalOrExternalEnum.INTERNAL + + +external = IfcInternalOrExternalEnum.EXTERNAL + + +external_earth = IfcInternalOrExternalEnum.EXTERNAL_EARTH + + +external_water = IfcInternalOrExternalEnum.EXTERNAL_WATER + + +external_fire = IfcInternalOrExternalEnum.EXTERNAL_FIRE + + +notdefined = IfcInternalOrExternalEnum.NOTDEFINED + + +IfcInventoryTypeEnum = enum_namespace() + + +assetinventory = IfcInventoryTypeEnum.ASSETINVENTORY + + +spaceinventory = IfcInventoryTypeEnum.SPACEINVENTORY + + +furnitureinventory = IfcInventoryTypeEnum.FURNITUREINVENTORY + + +userdefined = IfcInventoryTypeEnum.USERDEFINED + + +notdefined = IfcInventoryTypeEnum.NOTDEFINED + + +IfcJunctionBoxTypeEnum = enum_namespace() + + +data = IfcJunctionBoxTypeEnum.DATA + + +power = IfcJunctionBoxTypeEnum.POWER + + +userdefined = IfcJunctionBoxTypeEnum.USERDEFINED + + +notdefined = IfcJunctionBoxTypeEnum.NOTDEFINED + + +IfcKnotType = enum_namespace() + + +uniform_knots = IfcKnotType.UNIFORM_KNOTS + + +quasi_uniform_knots = IfcKnotType.QUASI_UNIFORM_KNOTS + + +piecewise_bezier_knots = IfcKnotType.PIECEWISE_BEZIER_KNOTS + + +unspecified = IfcKnotType.UNSPECIFIED + + +IfcLaborResourceTypeEnum = enum_namespace() + + +administration = IfcLaborResourceTypeEnum.ADMINISTRATION + + +carpentry = IfcLaborResourceTypeEnum.CARPENTRY + + +cleaning = IfcLaborResourceTypeEnum.CLEANING + + +concrete = IfcLaborResourceTypeEnum.CONCRETE + + +drywall = IfcLaborResourceTypeEnum.DRYWALL + + +electric = IfcLaborResourceTypeEnum.ELECTRIC + + +finishing = IfcLaborResourceTypeEnum.FINISHING + + +flooring = IfcLaborResourceTypeEnum.FLOORING + + +general = IfcLaborResourceTypeEnum.GENERAL + + +hvac = IfcLaborResourceTypeEnum.HVAC + + +landscaping = IfcLaborResourceTypeEnum.LANDSCAPING + + +masonry = IfcLaborResourceTypeEnum.MASONRY + + +painting = IfcLaborResourceTypeEnum.PAINTING + + +paving = IfcLaborResourceTypeEnum.PAVING + + +plumbing = IfcLaborResourceTypeEnum.PLUMBING + + +roofing = IfcLaborResourceTypeEnum.ROOFING + + +sitegrading = IfcLaborResourceTypeEnum.SITEGRADING + + +steelwork = IfcLaborResourceTypeEnum.STEELWORK + + +surveying = IfcLaborResourceTypeEnum.SURVEYING + + +userdefined = IfcLaborResourceTypeEnum.USERDEFINED + + +notdefined = IfcLaborResourceTypeEnum.NOTDEFINED + + +IfcLampTypeEnum = enum_namespace() + + +compactfluorescent = IfcLampTypeEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLampTypeEnum.FLUORESCENT + + +halogen = IfcLampTypeEnum.HALOGEN + + +highpressuremercury = IfcLampTypeEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLampTypeEnum.HIGHPRESSURESODIUM + + +led = IfcLampTypeEnum.LED + + +metalhalide = IfcLampTypeEnum.METALHALIDE + + +oled = IfcLampTypeEnum.OLED + + +tungstenfilament = IfcLampTypeEnum.TUNGSTENFILAMENT + + +userdefined = IfcLampTypeEnum.USERDEFINED + + +notdefined = IfcLampTypeEnum.NOTDEFINED + + +IfcLayerSetDirectionEnum = enum_namespace() + + +axis1 = IfcLayerSetDirectionEnum.AXIS1 + + +axis2 = IfcLayerSetDirectionEnum.AXIS2 + + +axis3 = IfcLayerSetDirectionEnum.AXIS3 + + +IfcLightDistributionCurveEnum = enum_namespace() + + +type_a = IfcLightDistributionCurveEnum.TYPE_A + + +type_b = IfcLightDistributionCurveEnum.TYPE_B + + +type_c = IfcLightDistributionCurveEnum.TYPE_C + + +notdefined = IfcLightDistributionCurveEnum.NOTDEFINED + + +IfcLightEmissionSourceEnum = enum_namespace() + + +compactfluorescent = IfcLightEmissionSourceEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLightEmissionSourceEnum.FLUORESCENT + + +highpressuremercury = IfcLightEmissionSourceEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLightEmissionSourceEnum.HIGHPRESSURESODIUM + + +lightemittingdiode = IfcLightEmissionSourceEnum.LIGHTEMITTINGDIODE + + +lowpressuresodium = IfcLightEmissionSourceEnum.LOWPRESSURESODIUM + + +lowvoltagehalogen = IfcLightEmissionSourceEnum.LOWVOLTAGEHALOGEN + + +mainvoltagehalogen = IfcLightEmissionSourceEnum.MAINVOLTAGEHALOGEN + + +metalhalide = IfcLightEmissionSourceEnum.METALHALIDE + + +tungstenfilament = IfcLightEmissionSourceEnum.TUNGSTENFILAMENT + + +notdefined = IfcLightEmissionSourceEnum.NOTDEFINED + + +IfcLightFixtureTypeEnum = enum_namespace() + + +pointsource = IfcLightFixtureTypeEnum.POINTSOURCE + + +directionsource = IfcLightFixtureTypeEnum.DIRECTIONSOURCE + + +securitylighting = IfcLightFixtureTypeEnum.SECURITYLIGHTING + + +userdefined = IfcLightFixtureTypeEnum.USERDEFINED + + +notdefined = IfcLightFixtureTypeEnum.NOTDEFINED + + +IfcLiquidTerminalTypeEnum = enum_namespace() + + +loadingarm = IfcLiquidTerminalTypeEnum.LOADINGARM + + +hosereel = IfcLiquidTerminalTypeEnum.HOSEREEL + + +userdefined = IfcLiquidTerminalTypeEnum.USERDEFINED + + +notdefined = IfcLiquidTerminalTypeEnum.NOTDEFINED + + +IfcLoadGroupTypeEnum = enum_namespace() + + +load_group = IfcLoadGroupTypeEnum.LOAD_GROUP + + +load_case = IfcLoadGroupTypeEnum.LOAD_CASE + + +load_combination = IfcLoadGroupTypeEnum.LOAD_COMBINATION + + +userdefined = IfcLoadGroupTypeEnum.USERDEFINED + + +notdefined = IfcLoadGroupTypeEnum.NOTDEFINED + + +IfcLogicalOperatorEnum = enum_namespace() + + +logicaland = IfcLogicalOperatorEnum.LOGICALAND + + +logicalor = IfcLogicalOperatorEnum.LOGICALOR + + +logicalxor = IfcLogicalOperatorEnum.LOGICALXOR + + +logicalnotand = IfcLogicalOperatorEnum.LOGICALNOTAND + + +logicalnotor = IfcLogicalOperatorEnum.LOGICALNOTOR + + +IfcMarineFacilityTypeEnum = enum_namespace() + + +canal = IfcMarineFacilityTypeEnum.CANAL + + +waterwayshiplift = IfcMarineFacilityTypeEnum.WATERWAYSHIPLIFT + + +embankment = IfcMarineFacilityTypeEnum.EMBANKMENT + + +launchrecovery = IfcMarineFacilityTypeEnum.LAUNCHRECOVERY + + +marinedefence = IfcMarineFacilityTypeEnum.MARINEDEFENCE + + +hydrolift = IfcMarineFacilityTypeEnum.HYDROLIFT + + +shipyard = IfcMarineFacilityTypeEnum.SHIPYARD + + +shiplift = IfcMarineFacilityTypeEnum.SHIPLIFT + + +port = IfcMarineFacilityTypeEnum.PORT + + +quay = IfcMarineFacilityTypeEnum.QUAY + + +floatingdock = IfcMarineFacilityTypeEnum.FLOATINGDOCK + + +navigationalchannel = IfcMarineFacilityTypeEnum.NAVIGATIONALCHANNEL + + +breakwater = IfcMarineFacilityTypeEnum.BREAKWATER + + +drydock = IfcMarineFacilityTypeEnum.DRYDOCK + + +jetty = IfcMarineFacilityTypeEnum.JETTY + + +shiplock = IfcMarineFacilityTypeEnum.SHIPLOCK + + +barrierbeach = IfcMarineFacilityTypeEnum.BARRIERBEACH + + +slipway = IfcMarineFacilityTypeEnum.SLIPWAY + + +waterway = IfcMarineFacilityTypeEnum.WATERWAY + + +userdefined = IfcMarineFacilityTypeEnum.USERDEFINED + + +notdefined = IfcMarineFacilityTypeEnum.NOTDEFINED + + +IfcMarinePartTypeEnum = enum_namespace() + + +crest = IfcMarinePartTypeEnum.CREST + + +manufacturing = IfcMarinePartTypeEnum.MANUFACTURING + + +lowwaterline = IfcMarinePartTypeEnum.LOWWATERLINE + + +core = IfcMarinePartTypeEnum.CORE + + +waterfield = IfcMarinePartTypeEnum.WATERFIELD + + +cill_level = IfcMarinePartTypeEnum.CILL_LEVEL + + +berthingstructure = IfcMarinePartTypeEnum.BERTHINGSTRUCTURE + + +copelevel = IfcMarinePartTypeEnum.COPELEVEL + + +chamber = IfcMarinePartTypeEnum.CHAMBER + + +storage = IfcMarinePartTypeEnum.STORAGE + + +approachchannel = IfcMarinePartTypeEnum.APPROACHCHANNEL + + +vehicleservicing = IfcMarinePartTypeEnum.VEHICLESERVICING + + +shiptransfer = IfcMarinePartTypeEnum.SHIPTRANSFER + + +gatehead = IfcMarinePartTypeEnum.GATEHEAD + + +gudingstructure = IfcMarinePartTypeEnum.GUDINGSTRUCTURE + + +belowwaterline = IfcMarinePartTypeEnum.BELOWWATERLINE + + +weatherside = IfcMarinePartTypeEnum.WEATHERSIDE + + +landfield = IfcMarinePartTypeEnum.LANDFIELD + + +protection = IfcMarinePartTypeEnum.PROTECTION + + +leewardside = IfcMarinePartTypeEnum.LEEWARDSIDE + + +abovewaterline = IfcMarinePartTypeEnum.ABOVEWATERLINE + + +anchorage = IfcMarinePartTypeEnum.ANCHORAGE + + +navigationalarea = IfcMarinePartTypeEnum.NAVIGATIONALAREA + + +highwaterline = IfcMarinePartTypeEnum.HIGHWATERLINE + + +userdefined = IfcMarinePartTypeEnum.USERDEFINED + + +notdefined = IfcMarinePartTypeEnum.NOTDEFINED + + +IfcMechanicalFastenerTypeEnum = enum_namespace() + + +anchorbolt = IfcMechanicalFastenerTypeEnum.ANCHORBOLT + + +bolt = IfcMechanicalFastenerTypeEnum.BOLT + + +dowel = IfcMechanicalFastenerTypeEnum.DOWEL + + +nail = IfcMechanicalFastenerTypeEnum.NAIL + + +nailplate = IfcMechanicalFastenerTypeEnum.NAILPLATE + + +rivet = IfcMechanicalFastenerTypeEnum.RIVET + + +screw = IfcMechanicalFastenerTypeEnum.SCREW + + +shearconnector = IfcMechanicalFastenerTypeEnum.SHEARCONNECTOR + + +staple = IfcMechanicalFastenerTypeEnum.STAPLE + + +studshearconnector = IfcMechanicalFastenerTypeEnum.STUDSHEARCONNECTOR + + +coupler = IfcMechanicalFastenerTypeEnum.COUPLER + + +railjoint = IfcMechanicalFastenerTypeEnum.RAILJOINT + + +railfastening = IfcMechanicalFastenerTypeEnum.RAILFASTENING + + +chain = IfcMechanicalFastenerTypeEnum.CHAIN + + +rope = IfcMechanicalFastenerTypeEnum.ROPE + + +userdefined = IfcMechanicalFastenerTypeEnum.USERDEFINED + + +notdefined = IfcMechanicalFastenerTypeEnum.NOTDEFINED + + +IfcMedicalDeviceTypeEnum = enum_namespace() + + +airstation = IfcMedicalDeviceTypeEnum.AIRSTATION + + +feedairunit = IfcMedicalDeviceTypeEnum.FEEDAIRUNIT + + +oxygengenerator = IfcMedicalDeviceTypeEnum.OXYGENGENERATOR + + +oxygenplant = IfcMedicalDeviceTypeEnum.OXYGENPLANT + + +vacuumstation = IfcMedicalDeviceTypeEnum.VACUUMSTATION + + +userdefined = IfcMedicalDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMedicalDeviceTypeEnum.NOTDEFINED + + +IfcMemberTypeEnum = enum_namespace() + + +brace = IfcMemberTypeEnum.BRACE + + +chord = IfcMemberTypeEnum.CHORD + + +collar = IfcMemberTypeEnum.COLLAR + + +member = IfcMemberTypeEnum.MEMBER + + +mullion = IfcMemberTypeEnum.MULLION + + +plate = IfcMemberTypeEnum.PLATE + + +post = IfcMemberTypeEnum.POST + + +purlin = IfcMemberTypeEnum.PURLIN + + +rafter = IfcMemberTypeEnum.RAFTER + + +stringer = IfcMemberTypeEnum.STRINGER + + +strut = IfcMemberTypeEnum.STRUT + + +stud = IfcMemberTypeEnum.STUD + + +stiffening_rib = IfcMemberTypeEnum.STIFFENING_RIB + + +arch_segment = IfcMemberTypeEnum.ARCH_SEGMENT + + +suspension_cable = IfcMemberTypeEnum.SUSPENSION_CABLE + + +suspender = IfcMemberTypeEnum.SUSPENDER + + +stay_cable = IfcMemberTypeEnum.STAY_CABLE + + +structuralcable = IfcMemberTypeEnum.STRUCTURALCABLE + + +tiebar = IfcMemberTypeEnum.TIEBAR + + +userdefined = IfcMemberTypeEnum.USERDEFINED + + +notdefined = IfcMemberTypeEnum.NOTDEFINED + + +IfcMobileTelecommunicationsApplianceTypeEnum = enum_namespace() + + +e_utran_node_b = IfcMobileTelecommunicationsApplianceTypeEnum.E_UTRAN_NODE_B + + +remote_radio_unit = IfcMobileTelecommunicationsApplianceTypeEnum.REMOTE_RADIO_UNIT + + +accesspoint = IfcMobileTelecommunicationsApplianceTypeEnum.ACCESSPOINT + + +basetransceiverstation = IfcMobileTelecommunicationsApplianceTypeEnum.BASETRANSCEIVERSTATION + + +remoteunit = IfcMobileTelecommunicationsApplianceTypeEnum.REMOTEUNIT + + +basebandunit = IfcMobileTelecommunicationsApplianceTypeEnum.BASEBANDUNIT + + +masterunit = IfcMobileTelecommunicationsApplianceTypeEnum.MASTERUNIT + + +userdefined = IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcMobileTelecommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcMooringDeviceTypeEnum = enum_namespace() + + +linetensioner = IfcMooringDeviceTypeEnum.LINETENSIONER + + +magneticdevice = IfcMooringDeviceTypeEnum.MAGNETICDEVICE + + +mooringhooks = IfcMooringDeviceTypeEnum.MOORINGHOOKS + + +vacuumdevice = IfcMooringDeviceTypeEnum.VACUUMDEVICE + + +bollard = IfcMooringDeviceTypeEnum.BOLLARD + + +userdefined = IfcMooringDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMooringDeviceTypeEnum.NOTDEFINED + + +IfcMotorConnectionTypeEnum = enum_namespace() + + +beltdrive = IfcMotorConnectionTypeEnum.BELTDRIVE + + +coupling = IfcMotorConnectionTypeEnum.COUPLING + + +directdrive = IfcMotorConnectionTypeEnum.DIRECTDRIVE + + +userdefined = IfcMotorConnectionTypeEnum.USERDEFINED + + +notdefined = IfcMotorConnectionTypeEnum.NOTDEFINED + + +IfcNavigationElementTypeEnum = enum_namespace() + + +beacon = IfcNavigationElementTypeEnum.BEACON + + +buoy = IfcNavigationElementTypeEnum.BUOY + + +userdefined = IfcNavigationElementTypeEnum.USERDEFINED + + +notdefined = IfcNavigationElementTypeEnum.NOTDEFINED + + +IfcNullStyle = enum_namespace() + + +null = IfcNullStyle.NULL + + +IfcObjectTypeEnum = enum_namespace() + + +product = IfcObjectTypeEnum.PRODUCT + + +process = IfcObjectTypeEnum.PROCESS + + +control = IfcObjectTypeEnum.CONTROL + + +resource = IfcObjectTypeEnum.RESOURCE + + +actor = IfcObjectTypeEnum.ACTOR + + +group = IfcObjectTypeEnum.GROUP + + +project = IfcObjectTypeEnum.PROJECT + + +notdefined = IfcObjectTypeEnum.NOTDEFINED + + +IfcObjectiveEnum = enum_namespace() + + +codecompliance = IfcObjectiveEnum.CODECOMPLIANCE + + +codewaiver = IfcObjectiveEnum.CODEWAIVER + + +designintent = IfcObjectiveEnum.DESIGNINTENT + + +external = IfcObjectiveEnum.EXTERNAL + + +healthandsafety = IfcObjectiveEnum.HEALTHANDSAFETY + + +mergeconflict = IfcObjectiveEnum.MERGECONFLICT + + +modelview = IfcObjectiveEnum.MODELVIEW + + +parameter = IfcObjectiveEnum.PARAMETER + + +requirement = IfcObjectiveEnum.REQUIREMENT + + +specification = IfcObjectiveEnum.SPECIFICATION + + +triggercondition = IfcObjectiveEnum.TRIGGERCONDITION + + +userdefined = IfcObjectiveEnum.USERDEFINED + + +notdefined = IfcObjectiveEnum.NOTDEFINED + + +IfcOccupantTypeEnum = enum_namespace() + + +assignee = IfcOccupantTypeEnum.ASSIGNEE + + +assignor = IfcOccupantTypeEnum.ASSIGNOR + + +lessee = IfcOccupantTypeEnum.LESSEE + + +lessor = IfcOccupantTypeEnum.LESSOR + + +lettingagent = IfcOccupantTypeEnum.LETTINGAGENT + + +owner = IfcOccupantTypeEnum.OWNER + + +tenant = IfcOccupantTypeEnum.TENANT + + +userdefined = IfcOccupantTypeEnum.USERDEFINED + + +notdefined = IfcOccupantTypeEnum.NOTDEFINED + + +IfcOpeningElementTypeEnum = enum_namespace() + + +opening = IfcOpeningElementTypeEnum.OPENING + + +recess = IfcOpeningElementTypeEnum.RECESS + + +userdefined = IfcOpeningElementTypeEnum.USERDEFINED + + +notdefined = IfcOpeningElementTypeEnum.NOTDEFINED + + +IfcOutletTypeEnum = enum_namespace() + + +audiovisualoutlet = IfcOutletTypeEnum.AUDIOVISUALOUTLET + + +communicationsoutlet = IfcOutletTypeEnum.COMMUNICATIONSOUTLET + + +poweroutlet = IfcOutletTypeEnum.POWEROUTLET + + +dataoutlet = IfcOutletTypeEnum.DATAOUTLET + + +telephoneoutlet = IfcOutletTypeEnum.TELEPHONEOUTLET + + +userdefined = IfcOutletTypeEnum.USERDEFINED + + +notdefined = IfcOutletTypeEnum.NOTDEFINED + + +IfcPerformanceHistoryTypeEnum = enum_namespace() + + +userdefined = IfcPerformanceHistoryTypeEnum.USERDEFINED + + +notdefined = IfcPerformanceHistoryTypeEnum.NOTDEFINED + + +IfcPermeableCoveringOperationEnum = enum_namespace() + + +grill = IfcPermeableCoveringOperationEnum.GRILL + + +louver = IfcPermeableCoveringOperationEnum.LOUVER + + +screen = IfcPermeableCoveringOperationEnum.SCREEN + + +userdefined = IfcPermeableCoveringOperationEnum.USERDEFINED + + +notdefined = IfcPermeableCoveringOperationEnum.NOTDEFINED + + +IfcPermitTypeEnum = enum_namespace() + + +access = IfcPermitTypeEnum.ACCESS + + +building = IfcPermitTypeEnum.BUILDING + + +work = IfcPermitTypeEnum.WORK + + +userdefined = IfcPermitTypeEnum.USERDEFINED + + +notdefined = IfcPermitTypeEnum.NOTDEFINED + + +IfcPhysicalOrVirtualEnum = enum_namespace() + + +physical = IfcPhysicalOrVirtualEnum.PHYSICAL + + +virtual = IfcPhysicalOrVirtualEnum.VIRTUAL + + +notdefined = IfcPhysicalOrVirtualEnum.NOTDEFINED + + +IfcPileConstructionEnum = enum_namespace() + + +cast_in_place = IfcPileConstructionEnum.CAST_IN_PLACE + + +composite = IfcPileConstructionEnum.COMPOSITE + + +precast_concrete = IfcPileConstructionEnum.PRECAST_CONCRETE + + +prefab_steel = IfcPileConstructionEnum.PREFAB_STEEL + + +userdefined = IfcPileConstructionEnum.USERDEFINED + + +notdefined = IfcPileConstructionEnum.NOTDEFINED + + +IfcPileTypeEnum = enum_namespace() + + +bored = IfcPileTypeEnum.BORED + + +driven = IfcPileTypeEnum.DRIVEN + + +jetgrouting = IfcPileTypeEnum.JETGROUTING + + +cohesion = IfcPileTypeEnum.COHESION + + +friction = IfcPileTypeEnum.FRICTION + + +support = IfcPileTypeEnum.SUPPORT + + +userdefined = IfcPileTypeEnum.USERDEFINED + + +notdefined = IfcPileTypeEnum.NOTDEFINED + + +IfcPipeFittingTypeEnum = enum_namespace() + + +bend = IfcPipeFittingTypeEnum.BEND + + +connector = IfcPipeFittingTypeEnum.CONNECTOR + + +entry = IfcPipeFittingTypeEnum.ENTRY + + +exit = IfcPipeFittingTypeEnum.EXIT + + +junction = IfcPipeFittingTypeEnum.JUNCTION + + +obstruction = IfcPipeFittingTypeEnum.OBSTRUCTION + + +transition = IfcPipeFittingTypeEnum.TRANSITION + + +userdefined = IfcPipeFittingTypeEnum.USERDEFINED + + +notdefined = IfcPipeFittingTypeEnum.NOTDEFINED + + +IfcPipeSegmentTypeEnum = enum_namespace() + + +culvert = IfcPipeSegmentTypeEnum.CULVERT + + +flexiblesegment = IfcPipeSegmentTypeEnum.FLEXIBLESEGMENT + + +rigidsegment = IfcPipeSegmentTypeEnum.RIGIDSEGMENT + + +gutter = IfcPipeSegmentTypeEnum.GUTTER + + +spool = IfcPipeSegmentTypeEnum.SPOOL + + +userdefined = IfcPipeSegmentTypeEnum.USERDEFINED + + +notdefined = IfcPipeSegmentTypeEnum.NOTDEFINED + + +IfcPlateTypeEnum = enum_namespace() + + +curtain_panel = IfcPlateTypeEnum.CURTAIN_PANEL + + +sheet = IfcPlateTypeEnum.SHEET + + +flange_plate = IfcPlateTypeEnum.FLANGE_PLATE + + +web_plate = IfcPlateTypeEnum.WEB_PLATE + + +stiffener_plate = IfcPlateTypeEnum.STIFFENER_PLATE + + +gusset_plate = IfcPlateTypeEnum.GUSSET_PLATE + + +cover_plate = IfcPlateTypeEnum.COVER_PLATE + + +splice_plate = IfcPlateTypeEnum.SPLICE_PLATE + + +base_plate = IfcPlateTypeEnum.BASE_PLATE + + +userdefined = IfcPlateTypeEnum.USERDEFINED + + +notdefined = IfcPlateTypeEnum.NOTDEFINED + + +IfcPreferredSurfaceCurveRepresentation = enum_namespace() + + +curve3d = IfcPreferredSurfaceCurveRepresentation.CURVE3D + + +pcurve_s1 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S1 + + +pcurve_s2 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S2 + + +IfcProcedureTypeEnum = enum_namespace() + + +advice_caution = IfcProcedureTypeEnum.ADVICE_CAUTION + + +advice_note = IfcProcedureTypeEnum.ADVICE_NOTE + + +advice_warning = IfcProcedureTypeEnum.ADVICE_WARNING + + +calibration = IfcProcedureTypeEnum.CALIBRATION + + +diagnostic = IfcProcedureTypeEnum.DIAGNOSTIC + + +shutdown = IfcProcedureTypeEnum.SHUTDOWN + + +startup = IfcProcedureTypeEnum.STARTUP + + +userdefined = IfcProcedureTypeEnum.USERDEFINED + + +notdefined = IfcProcedureTypeEnum.NOTDEFINED + + +IfcProfileTypeEnum = enum_namespace() + + +curve = IfcProfileTypeEnum.CURVE + + +area = IfcProfileTypeEnum.AREA + + +IfcProjectOrderTypeEnum = enum_namespace() + + +changeorder = IfcProjectOrderTypeEnum.CHANGEORDER + + +maintenanceworkorder = IfcProjectOrderTypeEnum.MAINTENANCEWORKORDER + + +moveorder = IfcProjectOrderTypeEnum.MOVEORDER + + +purchaseorder = IfcProjectOrderTypeEnum.PURCHASEORDER + + +workorder = IfcProjectOrderTypeEnum.WORKORDER + + +userdefined = IfcProjectOrderTypeEnum.USERDEFINED + + +notdefined = IfcProjectOrderTypeEnum.NOTDEFINED + + +IfcProjectedOrTrueLengthEnum = enum_namespace() + + +projected_length = IfcProjectedOrTrueLengthEnum.PROJECTED_LENGTH + + +true_length = IfcProjectedOrTrueLengthEnum.TRUE_LENGTH + + +IfcProjectionElementTypeEnum = enum_namespace() + + +blister = IfcProjectionElementTypeEnum.BLISTER + + +deviator = IfcProjectionElementTypeEnum.DEVIATOR + + +userdefined = IfcProjectionElementTypeEnum.USERDEFINED + + +notdefined = IfcProjectionElementTypeEnum.NOTDEFINED + + +IfcPropertySetTemplateTypeEnum = enum_namespace() + + +pset_typedrivenonly = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENONLY + + +pset_typedrivenoverride = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENOVERRIDE + + +pset_occurrencedriven = IfcPropertySetTemplateTypeEnum.PSET_OCCURRENCEDRIVEN + + +pset_performancedriven = IfcPropertySetTemplateTypeEnum.PSET_PERFORMANCEDRIVEN + + +qto_typedrivenonly = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENONLY + + +qto_typedrivenoverride = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENOVERRIDE + + +qto_occurrencedriven = IfcPropertySetTemplateTypeEnum.QTO_OCCURRENCEDRIVEN + + +notdefined = IfcPropertySetTemplateTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTrippingUnitTypeEnum = enum_namespace() + + +electronic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTRONIC + + +electromagnetic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTROMAGNETIC + + +residualcurrent = IfcProtectiveDeviceTrippingUnitTypeEnum.RESIDUALCURRENT + + +thermal = IfcProtectiveDeviceTrippingUnitTypeEnum.THERMAL + + +userdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTypeEnum = enum_namespace() + + +circuitbreaker = IfcProtectiveDeviceTypeEnum.CIRCUITBREAKER + + +earthleakagecircuitbreaker = IfcProtectiveDeviceTypeEnum.EARTHLEAKAGECIRCUITBREAKER + + +earthingswitch = IfcProtectiveDeviceTypeEnum.EARTHINGSWITCH + + +fusedisconnector = IfcProtectiveDeviceTypeEnum.FUSEDISCONNECTOR + + +residualcurrentcircuitbreaker = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTCIRCUITBREAKER + + +residualcurrentswitch = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTSWITCH + + +varistor = IfcProtectiveDeviceTypeEnum.VARISTOR + + +anti_arcing_device = IfcProtectiveDeviceTypeEnum.ANTI_ARCING_DEVICE + + +sparkgap = IfcProtectiveDeviceTypeEnum.SPARKGAP + + +voltagelimiter = IfcProtectiveDeviceTypeEnum.VOLTAGELIMITER + + +userdefined = IfcProtectiveDeviceTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTypeEnum.NOTDEFINED + + +IfcPumpTypeEnum = enum_namespace() + + +circulator = IfcPumpTypeEnum.CIRCULATOR + + +endsuction = IfcPumpTypeEnum.ENDSUCTION + + +splitcase = IfcPumpTypeEnum.SPLITCASE + + +submersiblepump = IfcPumpTypeEnum.SUBMERSIBLEPUMP + + +sumppump = IfcPumpTypeEnum.SUMPPUMP + + +verticalinline = IfcPumpTypeEnum.VERTICALINLINE + + +verticalturbine = IfcPumpTypeEnum.VERTICALTURBINE + + +userdefined = IfcPumpTypeEnum.USERDEFINED + + +notdefined = IfcPumpTypeEnum.NOTDEFINED + + +IfcRailTypeEnum = enum_namespace() + + +rackrail = IfcRailTypeEnum.RACKRAIL + + +blade = IfcRailTypeEnum.BLADE + + +guardrail = IfcRailTypeEnum.GUARDRAIL + + +stockrail = IfcRailTypeEnum.STOCKRAIL + + +checkrail = IfcRailTypeEnum.CHECKRAIL + + +rail = IfcRailTypeEnum.RAIL + + +userdefined = IfcRailTypeEnum.USERDEFINED + + +notdefined = IfcRailTypeEnum.NOTDEFINED + + +IfcRailingTypeEnum = enum_namespace() + + +handrail = IfcRailingTypeEnum.HANDRAIL + + +guardrail = IfcRailingTypeEnum.GUARDRAIL + + +balustrade = IfcRailingTypeEnum.BALUSTRADE + + +fence = IfcRailingTypeEnum.FENCE + + +userdefined = IfcRailingTypeEnum.USERDEFINED + + +notdefined = IfcRailingTypeEnum.NOTDEFINED + + +IfcRailwayPartTypeEnum = enum_namespace() + + +trackstructure = IfcRailwayPartTypeEnum.TRACKSTRUCTURE + + +trackstructurepart = IfcRailwayPartTypeEnum.TRACKSTRUCTUREPART + + +linesidestructurepart = IfcRailwayPartTypeEnum.LINESIDESTRUCTUREPART + + +dilatationsuperstructure = IfcRailwayPartTypeEnum.DILATATIONSUPERSTRUCTURE + + +plaintracksupestructure = IfcRailwayPartTypeEnum.PLAINTRACKSUPESTRUCTURE + + +linesidestructure = IfcRailwayPartTypeEnum.LINESIDESTRUCTURE + + +superstructure = IfcRailwayPartTypeEnum.SUPERSTRUCTURE + + +turnoutsuperstructure = IfcRailwayPartTypeEnum.TURNOUTSUPERSTRUCTURE + + +userdefined = IfcRailwayPartTypeEnum.USERDEFINED + + +notdefined = IfcRailwayPartTypeEnum.NOTDEFINED + + +IfcRampFlightTypeEnum = enum_namespace() + + +straight = IfcRampFlightTypeEnum.STRAIGHT + + +spiral = IfcRampFlightTypeEnum.SPIRAL + + +userdefined = IfcRampFlightTypeEnum.USERDEFINED + + +notdefined = IfcRampFlightTypeEnum.NOTDEFINED + + +IfcRampTypeEnum = enum_namespace() + + +straight_run_ramp = IfcRampTypeEnum.STRAIGHT_RUN_RAMP + + +two_straight_run_ramp = IfcRampTypeEnum.TWO_STRAIGHT_RUN_RAMP + + +quarter_turn_ramp = IfcRampTypeEnum.QUARTER_TURN_RAMP + + +two_quarter_turn_ramp = IfcRampTypeEnum.TWO_QUARTER_TURN_RAMP + + +half_turn_ramp = IfcRampTypeEnum.HALF_TURN_RAMP + + +spiral_ramp = IfcRampTypeEnum.SPIRAL_RAMP + + +userdefined = IfcRampTypeEnum.USERDEFINED + + +notdefined = IfcRampTypeEnum.NOTDEFINED + + +IfcRecurrenceTypeEnum = enum_namespace() + + +daily = IfcRecurrenceTypeEnum.DAILY + + +weekly = IfcRecurrenceTypeEnum.WEEKLY + + +monthly_by_day_of_month = IfcRecurrenceTypeEnum.MONTHLY_BY_DAY_OF_MONTH + + +monthly_by_position = IfcRecurrenceTypeEnum.MONTHLY_BY_POSITION + + +by_day_count = IfcRecurrenceTypeEnum.BY_DAY_COUNT + + +by_weekday_count = IfcRecurrenceTypeEnum.BY_WEEKDAY_COUNT + + +yearly_by_day_of_month = IfcRecurrenceTypeEnum.YEARLY_BY_DAY_OF_MONTH + + +yearly_by_position = IfcRecurrenceTypeEnum.YEARLY_BY_POSITION + + +IfcReferentTypeEnum = enum_namespace() + + +kilopoint = IfcReferentTypeEnum.KILOPOINT + + +milepoint = IfcReferentTypeEnum.MILEPOINT + + +station = IfcReferentTypeEnum.STATION + + +referencemarker = IfcReferentTypeEnum.REFERENCEMARKER + + +userdefined = IfcReferentTypeEnum.USERDEFINED + + +notdefined = IfcReferentTypeEnum.NOTDEFINED + + +IfcReflectanceMethodEnum = enum_namespace() + + +blinn = IfcReflectanceMethodEnum.BLINN + + +flat = IfcReflectanceMethodEnum.FLAT + + +glass = IfcReflectanceMethodEnum.GLASS + + +matt = IfcReflectanceMethodEnum.MATT + + +metal = IfcReflectanceMethodEnum.METAL + + +mirror = IfcReflectanceMethodEnum.MIRROR + + +phong = IfcReflectanceMethodEnum.PHONG + + +plastic = IfcReflectanceMethodEnum.PLASTIC + + +strauss = IfcReflectanceMethodEnum.STRAUSS + + +notdefined = IfcReflectanceMethodEnum.NOTDEFINED + + +IfcReinforcedSoilTypeEnum = enum_namespace() + + +surchargepreloaded = IfcReinforcedSoilTypeEnum.SURCHARGEPRELOADED + + +verticallydrained = IfcReinforcedSoilTypeEnum.VERTICALLYDRAINED + + +dynamicallycompacted = IfcReinforcedSoilTypeEnum.DYNAMICALLYCOMPACTED + + +replaced = IfcReinforcedSoilTypeEnum.REPLACED + + +rollercompacted = IfcReinforcedSoilTypeEnum.ROLLERCOMPACTED + + +grouted = IfcReinforcedSoilTypeEnum.GROUTED + + +userdefined = IfcReinforcedSoilTypeEnum.USERDEFINED + + +notdefined = IfcReinforcedSoilTypeEnum.NOTDEFINED + + +IfcReinforcingBarRoleEnum = enum_namespace() + + +main = IfcReinforcingBarRoleEnum.MAIN + + +shear = IfcReinforcingBarRoleEnum.SHEAR + + +ligature = IfcReinforcingBarRoleEnum.LIGATURE + + +stud = IfcReinforcingBarRoleEnum.STUD + + +punching = IfcReinforcingBarRoleEnum.PUNCHING + + +edge = IfcReinforcingBarRoleEnum.EDGE + + +ring = IfcReinforcingBarRoleEnum.RING + + +anchoring = IfcReinforcingBarRoleEnum.ANCHORING + + +userdefined = IfcReinforcingBarRoleEnum.USERDEFINED + + +notdefined = IfcReinforcingBarRoleEnum.NOTDEFINED + + +IfcReinforcingBarSurfaceEnum = enum_namespace() + + +plain = IfcReinforcingBarSurfaceEnum.PLAIN + + +textured = IfcReinforcingBarSurfaceEnum.TEXTURED + + +IfcReinforcingBarTypeEnum = enum_namespace() + + +anchoring = IfcReinforcingBarTypeEnum.ANCHORING + + +edge = IfcReinforcingBarTypeEnum.EDGE + + +ligature = IfcReinforcingBarTypeEnum.LIGATURE + + +main = IfcReinforcingBarTypeEnum.MAIN + + +punching = IfcReinforcingBarTypeEnum.PUNCHING + + +ring = IfcReinforcingBarTypeEnum.RING + + +shear = IfcReinforcingBarTypeEnum.SHEAR + + +stud = IfcReinforcingBarTypeEnum.STUD + + +spacebar = IfcReinforcingBarTypeEnum.SPACEBAR + + +userdefined = IfcReinforcingBarTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingBarTypeEnum.NOTDEFINED + + +IfcReinforcingMeshTypeEnum = enum_namespace() + + +userdefined = IfcReinforcingMeshTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingMeshTypeEnum.NOTDEFINED + + +IfcRoadPartTypeEnum = enum_namespace() + + +roadsidepart = IfcRoadPartTypeEnum.ROADSIDEPART + + +bus_stop = IfcRoadPartTypeEnum.BUS_STOP + + +hardshoulder = IfcRoadPartTypeEnum.HARDSHOULDER + + +intersection = IfcRoadPartTypeEnum.INTERSECTION + + +passingbay = IfcRoadPartTypeEnum.PASSINGBAY + + +roadwayplateau = IfcRoadPartTypeEnum.ROADWAYPLATEAU + + +roadside = IfcRoadPartTypeEnum.ROADSIDE + + +refugeisland = IfcRoadPartTypeEnum.REFUGEISLAND + + +tollplaza = IfcRoadPartTypeEnum.TOLLPLAZA + + +centralreserve = IfcRoadPartTypeEnum.CENTRALRESERVE + + +sidewalk = IfcRoadPartTypeEnum.SIDEWALK + + +parkingbay = IfcRoadPartTypeEnum.PARKINGBAY + + +railwaycrossing = IfcRoadPartTypeEnum.RAILWAYCROSSING + + +pedestrian_crossing = IfcRoadPartTypeEnum.PEDESTRIAN_CROSSING + + +softshoulder = IfcRoadPartTypeEnum.SOFTSHOULDER + + +bicyclecrossing = IfcRoadPartTypeEnum.BICYCLECROSSING + + +centralisland = IfcRoadPartTypeEnum.CENTRALISLAND + + +shoulder = IfcRoadPartTypeEnum.SHOULDER + + +trafficlane = IfcRoadPartTypeEnum.TRAFFICLANE + + +roadsegment = IfcRoadPartTypeEnum.ROADSEGMENT + + +roundabout = IfcRoadPartTypeEnum.ROUNDABOUT + + +layby = IfcRoadPartTypeEnum.LAYBY + + +carriageway = IfcRoadPartTypeEnum.CARRIAGEWAY + + +trafficisland = IfcRoadPartTypeEnum.TRAFFICISLAND + + +userdefined = IfcRoadPartTypeEnum.USERDEFINED + + +notdefined = IfcRoadPartTypeEnum.NOTDEFINED + + +IfcRoleEnum = enum_namespace() + + +supplier = IfcRoleEnum.SUPPLIER + + +manufacturer = IfcRoleEnum.MANUFACTURER + + +contractor = IfcRoleEnum.CONTRACTOR + + +subcontractor = IfcRoleEnum.SUBCONTRACTOR + + +architect = IfcRoleEnum.ARCHITECT + + +structuralengineer = IfcRoleEnum.STRUCTURALENGINEER + + +costengineer = IfcRoleEnum.COSTENGINEER + + +client = IfcRoleEnum.CLIENT + + +buildingowner = IfcRoleEnum.BUILDINGOWNER + + +buildingoperator = IfcRoleEnum.BUILDINGOPERATOR + + +mechanicalengineer = IfcRoleEnum.MECHANICALENGINEER + + +electricalengineer = IfcRoleEnum.ELECTRICALENGINEER + + +projectmanager = IfcRoleEnum.PROJECTMANAGER + + +facilitiesmanager = IfcRoleEnum.FACILITIESMANAGER + + +civilengineer = IfcRoleEnum.CIVILENGINEER + + +commissioningengineer = IfcRoleEnum.COMMISSIONINGENGINEER + + +engineer = IfcRoleEnum.ENGINEER + + +owner = IfcRoleEnum.OWNER + + +consultant = IfcRoleEnum.CONSULTANT + + +constructionmanager = IfcRoleEnum.CONSTRUCTIONMANAGER + + +fieldconstructionmanager = IfcRoleEnum.FIELDCONSTRUCTIONMANAGER + + +reseller = IfcRoleEnum.RESELLER + + +userdefined = IfcRoleEnum.USERDEFINED + + +IfcRoofTypeEnum = enum_namespace() + + +flat_roof = IfcRoofTypeEnum.FLAT_ROOF + + +shed_roof = IfcRoofTypeEnum.SHED_ROOF + + +gable_roof = IfcRoofTypeEnum.GABLE_ROOF + + +hip_roof = IfcRoofTypeEnum.HIP_ROOF + + +hipped_gable_roof = IfcRoofTypeEnum.HIPPED_GABLE_ROOF + + +gambrel_roof = IfcRoofTypeEnum.GAMBREL_ROOF + + +mansard_roof = IfcRoofTypeEnum.MANSARD_ROOF + + +barrel_roof = IfcRoofTypeEnum.BARREL_ROOF + + +rainbow_roof = IfcRoofTypeEnum.RAINBOW_ROOF + + +butterfly_roof = IfcRoofTypeEnum.BUTTERFLY_ROOF + + +pavilion_roof = IfcRoofTypeEnum.PAVILION_ROOF + + +dome_roof = IfcRoofTypeEnum.DOME_ROOF + + +freeform = IfcRoofTypeEnum.FREEFORM + + +userdefined = IfcRoofTypeEnum.USERDEFINED + + +notdefined = IfcRoofTypeEnum.NOTDEFINED + + +IfcSIPrefix = enum_namespace() + + +exa = IfcSIPrefix.EXA + + +peta = IfcSIPrefix.PETA + + +tera = IfcSIPrefix.TERA + + +giga = IfcSIPrefix.GIGA + + +mega = IfcSIPrefix.MEGA + + +kilo = IfcSIPrefix.KILO + + +hecto = IfcSIPrefix.HECTO + + +deca = IfcSIPrefix.DECA + + +deci = IfcSIPrefix.DECI + + +centi = IfcSIPrefix.CENTI + + +milli = IfcSIPrefix.MILLI + + +micro = IfcSIPrefix.MICRO + + +nano = IfcSIPrefix.NANO + + +pico = IfcSIPrefix.PICO + + +femto = IfcSIPrefix.FEMTO + + +atto = IfcSIPrefix.ATTO + + +IfcSIUnitName = enum_namespace() + + +ampere = IfcSIUnitName.AMPERE + + +becquerel = IfcSIUnitName.BECQUEREL + + +candela = IfcSIUnitName.CANDELA + + +coulomb = IfcSIUnitName.COULOMB + + +cubic_metre = IfcSIUnitName.CUBIC_METRE + + +degree_celsius = IfcSIUnitName.DEGREE_CELSIUS + + +farad = IfcSIUnitName.FARAD + + +gram = IfcSIUnitName.GRAM + + +gray = IfcSIUnitName.GRAY + + +henry = IfcSIUnitName.HENRY + + +hertz = IfcSIUnitName.HERTZ + + +joule = IfcSIUnitName.JOULE + + +kelvin = IfcSIUnitName.KELVIN + + +lumen = IfcSIUnitName.LUMEN + + +lux = IfcSIUnitName.LUX + + +metre = IfcSIUnitName.METRE + + +mole = IfcSIUnitName.MOLE + + +newton = IfcSIUnitName.NEWTON + + +ohm = IfcSIUnitName.OHM + + +pascal = IfcSIUnitName.PASCAL + + +radian = IfcSIUnitName.RADIAN + + +second = IfcSIUnitName.SECOND + + +siemens = IfcSIUnitName.SIEMENS + + +sievert = IfcSIUnitName.SIEVERT + + +square_metre = IfcSIUnitName.SQUARE_METRE + + +steradian = IfcSIUnitName.STERADIAN + + +tesla = IfcSIUnitName.TESLA + + +volt = IfcSIUnitName.VOLT + + +watt = IfcSIUnitName.WATT + + +weber = IfcSIUnitName.WEBER + + +IfcSanitaryTerminalTypeEnum = enum_namespace() + + +bath = IfcSanitaryTerminalTypeEnum.BATH + + +bidet = IfcSanitaryTerminalTypeEnum.BIDET + + +cistern = IfcSanitaryTerminalTypeEnum.CISTERN + + +shower = IfcSanitaryTerminalTypeEnum.SHOWER + + +sink = IfcSanitaryTerminalTypeEnum.SINK + + +sanitaryfountain = IfcSanitaryTerminalTypeEnum.SANITARYFOUNTAIN + + +toiletpan = IfcSanitaryTerminalTypeEnum.TOILETPAN + + +urinal = IfcSanitaryTerminalTypeEnum.URINAL + + +washhandbasin = IfcSanitaryTerminalTypeEnum.WASHHANDBASIN + + +wcseat = IfcSanitaryTerminalTypeEnum.WCSEAT + + +userdefined = IfcSanitaryTerminalTypeEnum.USERDEFINED + + +notdefined = IfcSanitaryTerminalTypeEnum.NOTDEFINED + + +IfcSectionTypeEnum = enum_namespace() + + +uniform = IfcSectionTypeEnum.UNIFORM + + +tapered = IfcSectionTypeEnum.TAPERED + + +IfcSensorTypeEnum = enum_namespace() + + +cosensor = IfcSensorTypeEnum.COSENSOR + + +co2sensor = IfcSensorTypeEnum.CO2SENSOR + + +conductancesensor = IfcSensorTypeEnum.CONDUCTANCESENSOR + + +contactsensor = IfcSensorTypeEnum.CONTACTSENSOR + + +firesensor = IfcSensorTypeEnum.FIRESENSOR + + +flowsensor = IfcSensorTypeEnum.FLOWSENSOR + + +frostsensor = IfcSensorTypeEnum.FROSTSENSOR + + +gassensor = IfcSensorTypeEnum.GASSENSOR + + +heatsensor = IfcSensorTypeEnum.HEATSENSOR + + +humiditysensor = IfcSensorTypeEnum.HUMIDITYSENSOR + + +identifiersensor = IfcSensorTypeEnum.IDENTIFIERSENSOR + + +ionconcentrationsensor = IfcSensorTypeEnum.IONCONCENTRATIONSENSOR + + +levelsensor = IfcSensorTypeEnum.LEVELSENSOR + + +lightsensor = IfcSensorTypeEnum.LIGHTSENSOR + + +moisturesensor = IfcSensorTypeEnum.MOISTURESENSOR + + +movementsensor = IfcSensorTypeEnum.MOVEMENTSENSOR + + +phsensor = IfcSensorTypeEnum.PHSENSOR + + +pressuresensor = IfcSensorTypeEnum.PRESSURESENSOR + + +radiationsensor = IfcSensorTypeEnum.RADIATIONSENSOR + + +radioactivitysensor = IfcSensorTypeEnum.RADIOACTIVITYSENSOR + + +smokesensor = IfcSensorTypeEnum.SMOKESENSOR + + +soundsensor = IfcSensorTypeEnum.SOUNDSENSOR + + +temperaturesensor = IfcSensorTypeEnum.TEMPERATURESENSOR + + +windsensor = IfcSensorTypeEnum.WINDSENSOR + + +earthquakesensor = IfcSensorTypeEnum.EARTHQUAKESENSOR + + +foreignobjectdetectionsensor = IfcSensorTypeEnum.FOREIGNOBJECTDETECTIONSENSOR + + +obstaclesensor = IfcSensorTypeEnum.OBSTACLESENSOR + + +rainsensor = IfcSensorTypeEnum.RAINSENSOR + + +snowdepthsensor = IfcSensorTypeEnum.SNOWDEPTHSENSOR + + +trainsensor = IfcSensorTypeEnum.TRAINSENSOR + + +turnoutclosuresensor = IfcSensorTypeEnum.TURNOUTCLOSURESENSOR + + +wheelsensor = IfcSensorTypeEnum.WHEELSENSOR + + +userdefined = IfcSensorTypeEnum.USERDEFINED + + +notdefined = IfcSensorTypeEnum.NOTDEFINED + + +IfcSequenceEnum = enum_namespace() + + +start_start = IfcSequenceEnum.START_START + + +start_finish = IfcSequenceEnum.START_FINISH + + +finish_start = IfcSequenceEnum.FINISH_START + + +finish_finish = IfcSequenceEnum.FINISH_FINISH + + +userdefined = IfcSequenceEnum.USERDEFINED + + +notdefined = IfcSequenceEnum.NOTDEFINED + + +IfcShadingDeviceTypeEnum = enum_namespace() + + +jalousie = IfcShadingDeviceTypeEnum.JALOUSIE + + +shutter = IfcShadingDeviceTypeEnum.SHUTTER + + +awning = IfcShadingDeviceTypeEnum.AWNING + + +userdefined = IfcShadingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcShadingDeviceTypeEnum.NOTDEFINED + + +IfcSignTypeEnum = enum_namespace() + + +marker = IfcSignTypeEnum.MARKER + + +pictoral = IfcSignTypeEnum.PICTORAL + + +mirror = IfcSignTypeEnum.MIRROR + + +userdefined = IfcSignTypeEnum.USERDEFINED + + +notdefined = IfcSignTypeEnum.NOTDEFINED + + +IfcSignalTypeEnum = enum_namespace() + + +visual = IfcSignalTypeEnum.VISUAL + + +audio = IfcSignalTypeEnum.AUDIO + + +mixed = IfcSignalTypeEnum.MIXED + + +userdefined = IfcSignalTypeEnum.USERDEFINED + + +notdefined = IfcSignalTypeEnum.NOTDEFINED + + +IfcSimplePropertyTemplateTypeEnum = enum_namespace() + + +p_singlevalue = IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE + + +p_enumeratedvalue = IfcSimplePropertyTemplateTypeEnum.P_ENUMERATEDVALUE + + +p_boundedvalue = IfcSimplePropertyTemplateTypeEnum.P_BOUNDEDVALUE + + +p_listvalue = IfcSimplePropertyTemplateTypeEnum.P_LISTVALUE + + +p_tablevalue = IfcSimplePropertyTemplateTypeEnum.P_TABLEVALUE + + +p_referencevalue = IfcSimplePropertyTemplateTypeEnum.P_REFERENCEVALUE + + +q_length = IfcSimplePropertyTemplateTypeEnum.Q_LENGTH + + +q_area = IfcSimplePropertyTemplateTypeEnum.Q_AREA + + +q_volume = IfcSimplePropertyTemplateTypeEnum.Q_VOLUME + + +q_count = IfcSimplePropertyTemplateTypeEnum.Q_COUNT + + +q_weight = IfcSimplePropertyTemplateTypeEnum.Q_WEIGHT + + +q_time = IfcSimplePropertyTemplateTypeEnum.Q_TIME + + +IfcSlabTypeEnum = enum_namespace() + + +floor = IfcSlabTypeEnum.FLOOR + + +roof = IfcSlabTypeEnum.ROOF + + +landing = IfcSlabTypeEnum.LANDING + + +baseslab = IfcSlabTypeEnum.BASESLAB + + +approach_slab = IfcSlabTypeEnum.APPROACH_SLAB + + +paving = IfcSlabTypeEnum.PAVING + + +wearing = IfcSlabTypeEnum.WEARING + + +sidewalk = IfcSlabTypeEnum.SIDEWALK + + +trackslab = IfcSlabTypeEnum.TRACKSLAB + + +userdefined = IfcSlabTypeEnum.USERDEFINED + + +notdefined = IfcSlabTypeEnum.NOTDEFINED + + +IfcSolarDeviceTypeEnum = enum_namespace() + + +solarcollector = IfcSolarDeviceTypeEnum.SOLARCOLLECTOR + + +solarpanel = IfcSolarDeviceTypeEnum.SOLARPANEL + + +userdefined = IfcSolarDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSolarDeviceTypeEnum.NOTDEFINED + + +IfcSpaceHeaterTypeEnum = enum_namespace() + + +convector = IfcSpaceHeaterTypeEnum.CONVECTOR + + +radiator = IfcSpaceHeaterTypeEnum.RADIATOR + + +userdefined = IfcSpaceHeaterTypeEnum.USERDEFINED + + +notdefined = IfcSpaceHeaterTypeEnum.NOTDEFINED + + +IfcSpaceTypeEnum = enum_namespace() + + +space = IfcSpaceTypeEnum.SPACE + + +parking = IfcSpaceTypeEnum.PARKING + + +gfa = IfcSpaceTypeEnum.GFA + + +internal = IfcSpaceTypeEnum.INTERNAL + + +external = IfcSpaceTypeEnum.EXTERNAL + + +userdefined = IfcSpaceTypeEnum.USERDEFINED + + +notdefined = IfcSpaceTypeEnum.NOTDEFINED + + +IfcSpatialZoneTypeEnum = enum_namespace() + + +construction = IfcSpatialZoneTypeEnum.CONSTRUCTION + + +firesafety = IfcSpatialZoneTypeEnum.FIRESAFETY + + +lighting = IfcSpatialZoneTypeEnum.LIGHTING + + +occupancy = IfcSpatialZoneTypeEnum.OCCUPANCY + + +security = IfcSpatialZoneTypeEnum.SECURITY + + +thermal = IfcSpatialZoneTypeEnum.THERMAL + + +transport = IfcSpatialZoneTypeEnum.TRANSPORT + + +ventilation = IfcSpatialZoneTypeEnum.VENTILATION + + +reservation = IfcSpatialZoneTypeEnum.RESERVATION + + +userdefined = IfcSpatialZoneTypeEnum.USERDEFINED + + +notdefined = IfcSpatialZoneTypeEnum.NOTDEFINED + + +IfcStackTerminalTypeEnum = enum_namespace() + + +birdcage = IfcStackTerminalTypeEnum.BIRDCAGE + + +cowl = IfcStackTerminalTypeEnum.COWL + + +rainwaterhopper = IfcStackTerminalTypeEnum.RAINWATERHOPPER + + +userdefined = IfcStackTerminalTypeEnum.USERDEFINED + + +notdefined = IfcStackTerminalTypeEnum.NOTDEFINED + + +IfcStairFlightTypeEnum = enum_namespace() + + +straight = IfcStairFlightTypeEnum.STRAIGHT + + +winder = IfcStairFlightTypeEnum.WINDER + + +spiral = IfcStairFlightTypeEnum.SPIRAL + + +curved = IfcStairFlightTypeEnum.CURVED + + +freeform = IfcStairFlightTypeEnum.FREEFORM + + +userdefined = IfcStairFlightTypeEnum.USERDEFINED + + +notdefined = IfcStairFlightTypeEnum.NOTDEFINED + + +IfcStairTypeEnum = enum_namespace() + + +straight_run_stair = IfcStairTypeEnum.STRAIGHT_RUN_STAIR + + +two_straight_run_stair = IfcStairTypeEnum.TWO_STRAIGHT_RUN_STAIR + + +quarter_winding_stair = IfcStairTypeEnum.QUARTER_WINDING_STAIR + + +quarter_turn_stair = IfcStairTypeEnum.QUARTER_TURN_STAIR + + +half_winding_stair = IfcStairTypeEnum.HALF_WINDING_STAIR + + +half_turn_stair = IfcStairTypeEnum.HALF_TURN_STAIR + + +two_quarter_winding_stair = IfcStairTypeEnum.TWO_QUARTER_WINDING_STAIR + + +two_quarter_turn_stair = IfcStairTypeEnum.TWO_QUARTER_TURN_STAIR + + +three_quarter_winding_stair = IfcStairTypeEnum.THREE_QUARTER_WINDING_STAIR + + +three_quarter_turn_stair = IfcStairTypeEnum.THREE_QUARTER_TURN_STAIR + + +spiral_stair = IfcStairTypeEnum.SPIRAL_STAIR + + +double_return_stair = IfcStairTypeEnum.DOUBLE_RETURN_STAIR + + +curved_run_stair = IfcStairTypeEnum.CURVED_RUN_STAIR + + +two_curved_run_stair = IfcStairTypeEnum.TWO_CURVED_RUN_STAIR + + +ladder = IfcStairTypeEnum.LADDER + + +userdefined = IfcStairTypeEnum.USERDEFINED + + +notdefined = IfcStairTypeEnum.NOTDEFINED + + +IfcStateEnum = enum_namespace() + + +readwrite = IfcStateEnum.READWRITE + + +readonly = IfcStateEnum.READONLY + + +locked = IfcStateEnum.LOCKED + + +readwritelocked = IfcStateEnum.READWRITELOCKED + + +readonlylocked = IfcStateEnum.READONLYLOCKED + + +IfcStructuralCurveActivityTypeEnum = enum_namespace() + + +const = IfcStructuralCurveActivityTypeEnum.CONST + + +linear = IfcStructuralCurveActivityTypeEnum.LINEAR + + +polygonal = IfcStructuralCurveActivityTypeEnum.POLYGONAL + + +equidistant = IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + +sinus = IfcStructuralCurveActivityTypeEnum.SINUS + + +parabola = IfcStructuralCurveActivityTypeEnum.PARABOLA + + +discrete = IfcStructuralCurveActivityTypeEnum.DISCRETE + + +userdefined = IfcStructuralCurveActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveActivityTypeEnum.NOTDEFINED + + +IfcStructuralCurveMemberTypeEnum = enum_namespace() + + +rigid_joined_member = IfcStructuralCurveMemberTypeEnum.RIGID_JOINED_MEMBER + + +pin_joined_member = IfcStructuralCurveMemberTypeEnum.PIN_JOINED_MEMBER + + +cable = IfcStructuralCurveMemberTypeEnum.CABLE + + +tension_member = IfcStructuralCurveMemberTypeEnum.TENSION_MEMBER + + +compression_member = IfcStructuralCurveMemberTypeEnum.COMPRESSION_MEMBER + + +userdefined = IfcStructuralCurveMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveMemberTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceActivityTypeEnum = enum_namespace() + + +const = IfcStructuralSurfaceActivityTypeEnum.CONST + + +bilinear = IfcStructuralSurfaceActivityTypeEnum.BILINEAR + + +discrete = IfcStructuralSurfaceActivityTypeEnum.DISCRETE + + +isocontour = IfcStructuralSurfaceActivityTypeEnum.ISOCONTOUR + + +userdefined = IfcStructuralSurfaceActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceActivityTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceMemberTypeEnum = enum_namespace() + + +bending_element = IfcStructuralSurfaceMemberTypeEnum.BENDING_ELEMENT + + +membrane_element = IfcStructuralSurfaceMemberTypeEnum.MEMBRANE_ELEMENT + + +shell = IfcStructuralSurfaceMemberTypeEnum.SHELL + + +userdefined = IfcStructuralSurfaceMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceMemberTypeEnum.NOTDEFINED + + +IfcSubContractResourceTypeEnum = enum_namespace() + + +purchase = IfcSubContractResourceTypeEnum.PURCHASE + + +work = IfcSubContractResourceTypeEnum.WORK + + +userdefined = IfcSubContractResourceTypeEnum.USERDEFINED + + +notdefined = IfcSubContractResourceTypeEnum.NOTDEFINED + + +IfcSurfaceFeatureTypeEnum = enum_namespace() + + +mark = IfcSurfaceFeatureTypeEnum.MARK + + +tag = IfcSurfaceFeatureTypeEnum.TAG + + +treatment = IfcSurfaceFeatureTypeEnum.TREATMENT + + +defect = IfcSurfaceFeatureTypeEnum.DEFECT + + +hatchmarking = IfcSurfaceFeatureTypeEnum.HATCHMARKING + + +linemarking = IfcSurfaceFeatureTypeEnum.LINEMARKING + + +pavementsurfacemarking = IfcSurfaceFeatureTypeEnum.PAVEMENTSURFACEMARKING + + +symbolmarking = IfcSurfaceFeatureTypeEnum.SYMBOLMARKING + + +nonskidsurfacing = IfcSurfaceFeatureTypeEnum.NONSKIDSURFACING + + +rumblestrip = IfcSurfaceFeatureTypeEnum.RUMBLESTRIP + + +transverserumblestrip = IfcSurfaceFeatureTypeEnum.TRANSVERSERUMBLESTRIP + + +userdefined = IfcSurfaceFeatureTypeEnum.USERDEFINED + + +notdefined = IfcSurfaceFeatureTypeEnum.NOTDEFINED + + +IfcSurfaceSide = enum_namespace() + + +positive = IfcSurfaceSide.POSITIVE + + +negative = IfcSurfaceSide.NEGATIVE + + +both = IfcSurfaceSide.BOTH + + +IfcSwitchingDeviceTypeEnum = enum_namespace() + + +contactor = IfcSwitchingDeviceTypeEnum.CONTACTOR + + +dimmerswitch = IfcSwitchingDeviceTypeEnum.DIMMERSWITCH + + +emergencystop = IfcSwitchingDeviceTypeEnum.EMERGENCYSTOP + + +keypad = IfcSwitchingDeviceTypeEnum.KEYPAD + + +momentaryswitch = IfcSwitchingDeviceTypeEnum.MOMENTARYSWITCH + + +selectorswitch = IfcSwitchingDeviceTypeEnum.SELECTORSWITCH + + +starter = IfcSwitchingDeviceTypeEnum.STARTER + + +switchdisconnector = IfcSwitchingDeviceTypeEnum.SWITCHDISCONNECTOR + + +toggleswitch = IfcSwitchingDeviceTypeEnum.TOGGLESWITCH + + +relay = IfcSwitchingDeviceTypeEnum.RELAY + + +start_and_stop_equipment = IfcSwitchingDeviceTypeEnum.START_AND_STOP_EQUIPMENT + + +userdefined = IfcSwitchingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSwitchingDeviceTypeEnum.NOTDEFINED + + +IfcSystemFurnitureElementTypeEnum = enum_namespace() + + +panel = IfcSystemFurnitureElementTypeEnum.PANEL + + +worksurface = IfcSystemFurnitureElementTypeEnum.WORKSURFACE + + +subrack = IfcSystemFurnitureElementTypeEnum.SUBRACK + + +userdefined = IfcSystemFurnitureElementTypeEnum.USERDEFINED + + +notdefined = IfcSystemFurnitureElementTypeEnum.NOTDEFINED + + +IfcTankTypeEnum = enum_namespace() + + +basin = IfcTankTypeEnum.BASIN + + +breakpressure = IfcTankTypeEnum.BREAKPRESSURE + + +expansion = IfcTankTypeEnum.EXPANSION + + +feedandexpansion = IfcTankTypeEnum.FEEDANDEXPANSION + + +pressurevessel = IfcTankTypeEnum.PRESSUREVESSEL + + +storage = IfcTankTypeEnum.STORAGE + + +vessel = IfcTankTypeEnum.VESSEL + + +oilretentiontray = IfcTankTypeEnum.OILRETENTIONTRAY + + +userdefined = IfcTankTypeEnum.USERDEFINED + + +notdefined = IfcTankTypeEnum.NOTDEFINED + + +IfcTaskDurationEnum = enum_namespace() + + +elapsedtime = IfcTaskDurationEnum.ELAPSEDTIME + + +worktime = IfcTaskDurationEnum.WORKTIME + + +notdefined = IfcTaskDurationEnum.NOTDEFINED + + +IfcTaskTypeEnum = enum_namespace() + + +attendance = IfcTaskTypeEnum.ATTENDANCE + + +construction = IfcTaskTypeEnum.CONSTRUCTION + + +demolition = IfcTaskTypeEnum.DEMOLITION + + +dismantle = IfcTaskTypeEnum.DISMANTLE + + +disposal = IfcTaskTypeEnum.DISPOSAL + + +installation = IfcTaskTypeEnum.INSTALLATION + + +logistic = IfcTaskTypeEnum.LOGISTIC + + +maintenance = IfcTaskTypeEnum.MAINTENANCE + + +move = IfcTaskTypeEnum.MOVE + + +operation = IfcTaskTypeEnum.OPERATION + + +removal = IfcTaskTypeEnum.REMOVAL + + +renovation = IfcTaskTypeEnum.RENOVATION + + +userdefined = IfcTaskTypeEnum.USERDEFINED + + +notdefined = IfcTaskTypeEnum.NOTDEFINED + + +IfcTendonAnchorTypeEnum = enum_namespace() + + +coupler = IfcTendonAnchorTypeEnum.COUPLER + + +fixed_end = IfcTendonAnchorTypeEnum.FIXED_END + + +tensioning_end = IfcTendonAnchorTypeEnum.TENSIONING_END + + +userdefined = IfcTendonAnchorTypeEnum.USERDEFINED + + +notdefined = IfcTendonAnchorTypeEnum.NOTDEFINED + + +IfcTendonConduitTypeEnum = enum_namespace() + + +duct = IfcTendonConduitTypeEnum.DUCT + + +coupler = IfcTendonConduitTypeEnum.COUPLER + + +grouting_duct = IfcTendonConduitTypeEnum.GROUTING_DUCT + + +trumpet = IfcTendonConduitTypeEnum.TRUMPET + + +diabolo = IfcTendonConduitTypeEnum.DIABOLO + + +userdefined = IfcTendonConduitTypeEnum.USERDEFINED + + +notdefined = IfcTendonConduitTypeEnum.NOTDEFINED + + +IfcTendonTypeEnum = enum_namespace() + + +bar = IfcTendonTypeEnum.BAR + + +coated = IfcTendonTypeEnum.COATED + + +strand = IfcTendonTypeEnum.STRAND + + +wire = IfcTendonTypeEnum.WIRE + + +userdefined = IfcTendonTypeEnum.USERDEFINED + + +notdefined = IfcTendonTypeEnum.NOTDEFINED + + +IfcTextPath = enum_namespace() + + +left = IfcTextPath.LEFT + + +right = IfcTextPath.RIGHT + + +up = IfcTextPath.UP + + +down = IfcTextPath.DOWN + + +IfcTimeSeriesDataTypeEnum = enum_namespace() + + +continuous = IfcTimeSeriesDataTypeEnum.CONTINUOUS + + +discrete = IfcTimeSeriesDataTypeEnum.DISCRETE + + +discretebinary = IfcTimeSeriesDataTypeEnum.DISCRETEBINARY + + +piecewisebinary = IfcTimeSeriesDataTypeEnum.PIECEWISEBINARY + + +piecewiseconstant = IfcTimeSeriesDataTypeEnum.PIECEWISECONSTANT + + +piecewisecontinuous = IfcTimeSeriesDataTypeEnum.PIECEWISECONTINUOUS + + +notdefined = IfcTimeSeriesDataTypeEnum.NOTDEFINED + + +IfcTrackElementTypeEnum = enum_namespace() + + +trackendofalignment = IfcTrackElementTypeEnum.TRACKENDOFALIGNMENT + + +blockingdevice = IfcTrackElementTypeEnum.BLOCKINGDEVICE + + +vehiclestop = IfcTrackElementTypeEnum.VEHICLESTOP + + +sleeper = IfcTrackElementTypeEnum.SLEEPER + + +half_set_of_blades = IfcTrackElementTypeEnum.HALF_SET_OF_BLADES + + +speedregulator = IfcTrackElementTypeEnum.SPEEDREGULATOR + + +derailer = IfcTrackElementTypeEnum.DERAILER + + +frog = IfcTrackElementTypeEnum.FROG + + +userdefined = IfcTrackElementTypeEnum.USERDEFINED + + +notdefined = IfcTrackElementTypeEnum.NOTDEFINED + + +IfcTransformerTypeEnum = enum_namespace() + + +current = IfcTransformerTypeEnum.CURRENT + + +frequency = IfcTransformerTypeEnum.FREQUENCY + + +inverter = IfcTransformerTypeEnum.INVERTER + + +rectifier = IfcTransformerTypeEnum.RECTIFIER + + +voltage = IfcTransformerTypeEnum.VOLTAGE + + +chopper = IfcTransformerTypeEnum.CHOPPER + + +combined = IfcTransformerTypeEnum.COMBINED + + +userdefined = IfcTransformerTypeEnum.USERDEFINED + + +notdefined = IfcTransformerTypeEnum.NOTDEFINED + + +IfcTransitionCode = enum_namespace() + + +discontinuous = IfcTransitionCode.DISCONTINUOUS + + +continuous = IfcTransitionCode.CONTINUOUS + + +contsamegradient = IfcTransitionCode.CONTSAMEGRADIENT + + +contsamegradientsamecurvature = IfcTransitionCode.CONTSAMEGRADIENTSAMECURVATURE + + +IfcTransitionCurveType = enum_namespace() + + +biquadraticparabola = IfcTransitionCurveType.BIQUADRATICPARABOLA + + +blosscurve = IfcTransitionCurveType.BLOSSCURVE + + +clothoidcurve = IfcTransitionCurveType.CLOTHOIDCURVE + + +cosinecurve = IfcTransitionCurveType.COSINECURVE + + +cubicparabola = IfcTransitionCurveType.CUBICPARABOLA + + +sinecurve = IfcTransitionCurveType.SINECURVE + + +IfcTransportElementFixedTypeEnum = enum_namespace() + + +elevator = IfcTransportElementFixedTypeEnum.ELEVATOR + + +escalator = IfcTransportElementFixedTypeEnum.ESCALATOR + + +movingwalkway = IfcTransportElementFixedTypeEnum.MOVINGWALKWAY + + +craneway = IfcTransportElementFixedTypeEnum.CRANEWAY + + +liftinggear = IfcTransportElementFixedTypeEnum.LIFTINGGEAR + + +userdefined = IfcTransportElementFixedTypeEnum.USERDEFINED + + +notdefined = IfcTransportElementFixedTypeEnum.NOTDEFINED + + +IfcTransportElementNonFixedTypeEnum = enum_namespace() + + +vehicle = IfcTransportElementNonFixedTypeEnum.VEHICLE + + +vehicletracked = IfcTransportElementNonFixedTypeEnum.VEHICLETRACKED + + +rollingstock = IfcTransportElementNonFixedTypeEnum.ROLLINGSTOCK + + +vehiclewheeled = IfcTransportElementNonFixedTypeEnum.VEHICLEWHEELED + + +vehicleair = IfcTransportElementNonFixedTypeEnum.VEHICLEAIR + + +cargo = IfcTransportElementNonFixedTypeEnum.CARGO + + +vehiclemarine = IfcTransportElementNonFixedTypeEnum.VEHICLEMARINE + + +userdefined = IfcTransportElementNonFixedTypeEnum.USERDEFINED + + +notdefined = IfcTransportElementNonFixedTypeEnum.NOTDEFINED + + +IfcTrimmingPreference = enum_namespace() + + +cartesian = IfcTrimmingPreference.CARTESIAN + + +parameter = IfcTrimmingPreference.PARAMETER + + +unspecified = IfcTrimmingPreference.UNSPECIFIED + + +IfcTubeBundleTypeEnum = enum_namespace() + + +finned = IfcTubeBundleTypeEnum.FINNED + + +userdefined = IfcTubeBundleTypeEnum.USERDEFINED + + +notdefined = IfcTubeBundleTypeEnum.NOTDEFINED + + +IfcUnitEnum = enum_namespace() + + +absorbeddoseunit = IfcUnitEnum.ABSORBEDDOSEUNIT + + +amountofsubstanceunit = IfcUnitEnum.AMOUNTOFSUBSTANCEUNIT + + +areaunit = IfcUnitEnum.AREAUNIT + + +doseequivalentunit = IfcUnitEnum.DOSEEQUIVALENTUNIT + + +electriccapacitanceunit = IfcUnitEnum.ELECTRICCAPACITANCEUNIT + + +electricchargeunit = IfcUnitEnum.ELECTRICCHARGEUNIT + + +electricconductanceunit = IfcUnitEnum.ELECTRICCONDUCTANCEUNIT + + +electriccurrentunit = IfcUnitEnum.ELECTRICCURRENTUNIT + + +electricresistanceunit = IfcUnitEnum.ELECTRICRESISTANCEUNIT + + +electricvoltageunit = IfcUnitEnum.ELECTRICVOLTAGEUNIT + + +energyunit = IfcUnitEnum.ENERGYUNIT + + +forceunit = IfcUnitEnum.FORCEUNIT + + +frequencyunit = IfcUnitEnum.FREQUENCYUNIT + + +illuminanceunit = IfcUnitEnum.ILLUMINANCEUNIT + + +inductanceunit = IfcUnitEnum.INDUCTANCEUNIT + + +lengthunit = IfcUnitEnum.LENGTHUNIT + + +luminousfluxunit = IfcUnitEnum.LUMINOUSFLUXUNIT + + +luminousintensityunit = IfcUnitEnum.LUMINOUSINTENSITYUNIT + + +magneticfluxdensityunit = IfcUnitEnum.MAGNETICFLUXDENSITYUNIT + + +magneticfluxunit = IfcUnitEnum.MAGNETICFLUXUNIT + + +massunit = IfcUnitEnum.MASSUNIT + + +planeangleunit = IfcUnitEnum.PLANEANGLEUNIT + + +powerunit = IfcUnitEnum.POWERUNIT + + +pressureunit = IfcUnitEnum.PRESSUREUNIT + + +radioactivityunit = IfcUnitEnum.RADIOACTIVITYUNIT + + +solidangleunit = IfcUnitEnum.SOLIDANGLEUNIT + + +thermodynamictemperatureunit = IfcUnitEnum.THERMODYNAMICTEMPERATUREUNIT + + +timeunit = IfcUnitEnum.TIMEUNIT + + +volumeunit = IfcUnitEnum.VOLUMEUNIT + + +userdefined = IfcUnitEnum.USERDEFINED + + +IfcUnitaryControlElementTypeEnum = enum_namespace() + + +alarmpanel = IfcUnitaryControlElementTypeEnum.ALARMPANEL + + +controlpanel = IfcUnitaryControlElementTypeEnum.CONTROLPANEL + + +gasdetectionpanel = IfcUnitaryControlElementTypeEnum.GASDETECTIONPANEL + + +indicatorpanel = IfcUnitaryControlElementTypeEnum.INDICATORPANEL + + +mimicpanel = IfcUnitaryControlElementTypeEnum.MIMICPANEL + + +humidistat = IfcUnitaryControlElementTypeEnum.HUMIDISTAT + + +thermostat = IfcUnitaryControlElementTypeEnum.THERMOSTAT + + +weatherstation = IfcUnitaryControlElementTypeEnum.WEATHERSTATION + + +combined = IfcUnitaryControlElementTypeEnum.COMBINED + + +userdefined = IfcUnitaryControlElementTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryControlElementTypeEnum.NOTDEFINED + + +IfcUnitaryEquipmentTypeEnum = enum_namespace() + + +airhandler = IfcUnitaryEquipmentTypeEnum.AIRHANDLER + + +airconditioningunit = IfcUnitaryEquipmentTypeEnum.AIRCONDITIONINGUNIT + + +dehumidifier = IfcUnitaryEquipmentTypeEnum.DEHUMIDIFIER + + +splitsystem = IfcUnitaryEquipmentTypeEnum.SPLITSYSTEM + + +rooftopunit = IfcUnitaryEquipmentTypeEnum.ROOFTOPUNIT + + +userdefined = IfcUnitaryEquipmentTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryEquipmentTypeEnum.NOTDEFINED + + +IfcValveTypeEnum = enum_namespace() + + +airrelease = IfcValveTypeEnum.AIRRELEASE + + +antivacuum = IfcValveTypeEnum.ANTIVACUUM + + +changeover = IfcValveTypeEnum.CHANGEOVER + + +check = IfcValveTypeEnum.CHECK + + +commissioning = IfcValveTypeEnum.COMMISSIONING + + +diverting = IfcValveTypeEnum.DIVERTING + + +drawoffcock = IfcValveTypeEnum.DRAWOFFCOCK + + +doublecheck = IfcValveTypeEnum.DOUBLECHECK + + +doubleregulating = IfcValveTypeEnum.DOUBLEREGULATING + + +faucet = IfcValveTypeEnum.FAUCET + + +flushing = IfcValveTypeEnum.FLUSHING + + +gascock = IfcValveTypeEnum.GASCOCK + + +gastap = IfcValveTypeEnum.GASTAP + + +isolating = IfcValveTypeEnum.ISOLATING + + +mixing = IfcValveTypeEnum.MIXING + + +pressurereducing = IfcValveTypeEnum.PRESSUREREDUCING + + +pressurerelief = IfcValveTypeEnum.PRESSURERELIEF + + +regulating = IfcValveTypeEnum.REGULATING + + +safetycutoff = IfcValveTypeEnum.SAFETYCUTOFF + + +steamtrap = IfcValveTypeEnum.STEAMTRAP + + +stopcock = IfcValveTypeEnum.STOPCOCK + + +userdefined = IfcValveTypeEnum.USERDEFINED + + +notdefined = IfcValveTypeEnum.NOTDEFINED + + +IfcVibrationDamperTypeEnum = enum_namespace() + + +bending_yield = IfcVibrationDamperTypeEnum.BENDING_YIELD + + +shear_yield = IfcVibrationDamperTypeEnum.SHEAR_YIELD + + +axial_yield = IfcVibrationDamperTypeEnum.AXIAL_YIELD + + +friction = IfcVibrationDamperTypeEnum.FRICTION + + +viscous = IfcVibrationDamperTypeEnum.VISCOUS + + +rubber = IfcVibrationDamperTypeEnum.RUBBER + + +userdefined = IfcVibrationDamperTypeEnum.USERDEFINED + + +notdefined = IfcVibrationDamperTypeEnum.NOTDEFINED + + +IfcVibrationIsolatorTypeEnum = enum_namespace() + + +compression = IfcVibrationIsolatorTypeEnum.COMPRESSION + + +spring = IfcVibrationIsolatorTypeEnum.SPRING + + +base = IfcVibrationIsolatorTypeEnum.BASE + + +userdefined = IfcVibrationIsolatorTypeEnum.USERDEFINED + + +notdefined = IfcVibrationIsolatorTypeEnum.NOTDEFINED + + +IfcVoidingFeatureTypeEnum = enum_namespace() + + +cutout = IfcVoidingFeatureTypeEnum.CUTOUT + + +notch = IfcVoidingFeatureTypeEnum.NOTCH + + +hole = IfcVoidingFeatureTypeEnum.HOLE + + +miter = IfcVoidingFeatureTypeEnum.MITER + + +chamfer = IfcVoidingFeatureTypeEnum.CHAMFER + + +edge = IfcVoidingFeatureTypeEnum.EDGE + + +userdefined = IfcVoidingFeatureTypeEnum.USERDEFINED + + +notdefined = IfcVoidingFeatureTypeEnum.NOTDEFINED + + +IfcWallTypeEnum = enum_namespace() + + +movable = IfcWallTypeEnum.MOVABLE + + +parapet = IfcWallTypeEnum.PARAPET + + +partitioning = IfcWallTypeEnum.PARTITIONING + + +plumbingwall = IfcWallTypeEnum.PLUMBINGWALL + + +shear = IfcWallTypeEnum.SHEAR + + +solidwall = IfcWallTypeEnum.SOLIDWALL + + +standard = IfcWallTypeEnum.STANDARD + + +polygonal = IfcWallTypeEnum.POLYGONAL + + +elementedwall = IfcWallTypeEnum.ELEMENTEDWALL + + +retainingwall = IfcWallTypeEnum.RETAININGWALL + + +wavewall = IfcWallTypeEnum.WAVEWALL + + +userdefined = IfcWallTypeEnum.USERDEFINED + + +notdefined = IfcWallTypeEnum.NOTDEFINED + + +IfcWasteTerminalTypeEnum = enum_namespace() + + +floortrap = IfcWasteTerminalTypeEnum.FLOORTRAP + + +floorwaste = IfcWasteTerminalTypeEnum.FLOORWASTE + + +gullysump = IfcWasteTerminalTypeEnum.GULLYSUMP + + +gullytrap = IfcWasteTerminalTypeEnum.GULLYTRAP + + +roofdrain = IfcWasteTerminalTypeEnum.ROOFDRAIN + + +wastedisposalunit = IfcWasteTerminalTypeEnum.WASTEDISPOSALUNIT + + +wastetrap = IfcWasteTerminalTypeEnum.WASTETRAP + + +userdefined = IfcWasteTerminalTypeEnum.USERDEFINED + + +notdefined = IfcWasteTerminalTypeEnum.NOTDEFINED + + +IfcWindowPanelOperationEnum = enum_namespace() + + +sidehungrighthand = IfcWindowPanelOperationEnum.SIDEHUNGRIGHTHAND + + +sidehunglefthand = IfcWindowPanelOperationEnum.SIDEHUNGLEFTHAND + + +tiltandturnrighthand = IfcWindowPanelOperationEnum.TILTANDTURNRIGHTHAND + + +tiltandturnlefthand = IfcWindowPanelOperationEnum.TILTANDTURNLEFTHAND + + +tophung = IfcWindowPanelOperationEnum.TOPHUNG + + +bottomhung = IfcWindowPanelOperationEnum.BOTTOMHUNG + + +pivothorizontal = IfcWindowPanelOperationEnum.PIVOTHORIZONTAL + + +pivotvertical = IfcWindowPanelOperationEnum.PIVOTVERTICAL + + +slidinghorizontal = IfcWindowPanelOperationEnum.SLIDINGHORIZONTAL + + +slidingvertical = IfcWindowPanelOperationEnum.SLIDINGVERTICAL + + +removablecasement = IfcWindowPanelOperationEnum.REMOVABLECASEMENT + + +fixedcasement = IfcWindowPanelOperationEnum.FIXEDCASEMENT + + +otheroperation = IfcWindowPanelOperationEnum.OTHEROPERATION + + +notdefined = IfcWindowPanelOperationEnum.NOTDEFINED + + +IfcWindowPanelPositionEnum = enum_namespace() + + +left = IfcWindowPanelPositionEnum.LEFT + + +middle = IfcWindowPanelPositionEnum.MIDDLE + + +right = IfcWindowPanelPositionEnum.RIGHT + + +bottom = IfcWindowPanelPositionEnum.BOTTOM + + +top = IfcWindowPanelPositionEnum.TOP + + +notdefined = IfcWindowPanelPositionEnum.NOTDEFINED + + +IfcWindowStyleConstructionEnum = enum_namespace() + + +aluminium = IfcWindowStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcWindowStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcWindowStyleConstructionEnum.STEEL + + +wood = IfcWindowStyleConstructionEnum.WOOD + + +aluminium_wood = IfcWindowStyleConstructionEnum.ALUMINIUM_WOOD + + +plastic = IfcWindowStyleConstructionEnum.PLASTIC + + +other_construction = IfcWindowStyleConstructionEnum.OTHER_CONSTRUCTION + + +notdefined = IfcWindowStyleConstructionEnum.NOTDEFINED + + +IfcWindowStyleOperationEnum = enum_namespace() + + +single_panel = IfcWindowStyleOperationEnum.SINGLE_PANEL + + +double_panel_vertical = IfcWindowStyleOperationEnum.DOUBLE_PANEL_VERTICAL + + +double_panel_horizontal = IfcWindowStyleOperationEnum.DOUBLE_PANEL_HORIZONTAL + + +triple_panel_vertical = IfcWindowStyleOperationEnum.TRIPLE_PANEL_VERTICAL + + +triple_panel_bottom = IfcWindowStyleOperationEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_top = IfcWindowStyleOperationEnum.TRIPLE_PANEL_TOP + + +triple_panel_left = IfcWindowStyleOperationEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowStyleOperationEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_horizontal = IfcWindowStyleOperationEnum.TRIPLE_PANEL_HORIZONTAL + + +userdefined = IfcWindowStyleOperationEnum.USERDEFINED + + +notdefined = IfcWindowStyleOperationEnum.NOTDEFINED + + +IfcWindowTypeEnum = enum_namespace() + + +window = IfcWindowTypeEnum.WINDOW + + +skylight = IfcWindowTypeEnum.SKYLIGHT + + +lightdome = IfcWindowTypeEnum.LIGHTDOME + + +userdefined = IfcWindowTypeEnum.USERDEFINED + + +notdefined = IfcWindowTypeEnum.NOTDEFINED + + +IfcWindowTypePartitioningEnum = enum_namespace() + + +single_panel = IfcWindowTypePartitioningEnum.SINGLE_PANEL + + +double_panel_vertical = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_VERTICAL + + +double_panel_horizontal = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_HORIZONTAL + + +triple_panel_vertical = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_VERTICAL + + +triple_panel_bottom = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_top = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_TOP + + +triple_panel_left = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_horizontal = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_HORIZONTAL + + +userdefined = IfcWindowTypePartitioningEnum.USERDEFINED + + +notdefined = IfcWindowTypePartitioningEnum.NOTDEFINED + + +IfcWorkCalendarTypeEnum = enum_namespace() + + +firstshift = IfcWorkCalendarTypeEnum.FIRSTSHIFT + + +secondshift = IfcWorkCalendarTypeEnum.SECONDSHIFT + + +thirdshift = IfcWorkCalendarTypeEnum.THIRDSHIFT + + +userdefined = IfcWorkCalendarTypeEnum.USERDEFINED + + +notdefined = IfcWorkCalendarTypeEnum.NOTDEFINED + + +IfcWorkPlanTypeEnum = enum_namespace() + + +actual = IfcWorkPlanTypeEnum.ACTUAL + + +baseline = IfcWorkPlanTypeEnum.BASELINE + + +planned = IfcWorkPlanTypeEnum.PLANNED + + +userdefined = IfcWorkPlanTypeEnum.USERDEFINED + + +notdefined = IfcWorkPlanTypeEnum.NOTDEFINED + + +IfcWorkScheduleTypeEnum = enum_namespace() + + +actual = IfcWorkScheduleTypeEnum.ACTUAL + + +baseline = IfcWorkScheduleTypeEnum.BASELINE + + +planned = IfcWorkScheduleTypeEnum.PLANNED + + +userdefined = IfcWorkScheduleTypeEnum.USERDEFINED + + +notdefined = IfcWorkScheduleTypeEnum.NOTDEFINED + + +def IfcActionRequest(*args, **kwargs): return ifcopenshell.create_entity('IfcActionRequest', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcActor(*args, **kwargs): return ifcopenshell.create_entity('IfcActor', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcActorRole(*args, **kwargs): return ifcopenshell.create_entity('IfcActorRole', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcActuator(*args, **kwargs): return ifcopenshell.create_entity('IfcActuator', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcActuatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcActuatorType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcAddress', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAdvancedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrep', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAdvancedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrepWithVoids', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAdvancedFace(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedFace', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAirTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminal', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAirTerminalBox(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBox', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAirTerminalBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBoxType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAirTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAirToAirHeatRecovery(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecovery', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAirToAirHeatRecoveryType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecoveryType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlarm(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarm', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlarmType(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarmType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlignment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlignment2DCant(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DCant', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlignment2DCantSegLine(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DCantSegLine', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlignment2DCantSegTransition(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DCantSegTransition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlignment2DCantSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DCantSegment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlignment2DHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DHorizontal', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlignment2DHorizontalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DHorizontalSegment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlignment2DSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DSegment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlignment2DVerSegCircularArc(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerSegCircularArc', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlignment2DVerSegLine(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerSegLine', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlignment2DVerSegParabolicArc(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerSegParabolicArc', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlignment2DVerSegTransition(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerSegTransition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlignment2DVertical(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVertical', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlignment2DVerticalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerticalSegment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAlignmentCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAnnotation(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotation', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAnnotationFillArea(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationFillArea', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcApplication(*args, **kwargs): return ifcopenshell.create_entity('IfcApplication', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAppliedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcAppliedValue', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcApproval', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcApprovalRelationship', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcArbitraryClosedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryClosedProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcArbitraryOpenProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryOpenProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcArbitraryProfileDefWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryProfileDefWithVoids', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAsset(*args, **kwargs): return ifcopenshell.create_entity('IfcAsset', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAsymmetricIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcAsymmetricIShapeProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAudioVisualAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualAppliance', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAudioVisualApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualApplianceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAxis1Placement(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis1Placement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAxis2Placement2D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement2D', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAxis2Placement3D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement3D', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcAxisLateralInclination(*args, **kwargs): return ifcopenshell.create_entity('IfcAxisLateralInclination', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBSplineCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurveWithKnots', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBSplineSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurface', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurfaceWithKnots', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcBeam', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBeamStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamStandardCase', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBearing(*args, **kwargs): return ifcopenshell.create_entity('IfcBearing', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBearingType(*args, **kwargs): return ifcopenshell.create_entity('IfcBearingType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBlobTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcBlobTexture', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBlock(*args, **kwargs): return ifcopenshell.create_entity('IfcBlock', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBoiler(*args, **kwargs): return ifcopenshell.create_entity('IfcBoiler', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBoilerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBoilerType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBooleanClippingResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanClippingResult', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBooleanResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanResult', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBorehole(*args, **kwargs): return ifcopenshell.create_entity('IfcBorehole', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBoundaryCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCondition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBoundaryEdgeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryEdgeCondition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBoundaryFaceCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryFaceCondition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBoundaryNodeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeCondition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBoundaryNodeConditionWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeConditionWarping', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBoundedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedCurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedSurface', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBoundingBox(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundingBox', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBoxedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcBoxedHalfSpace', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBridge(*args, **kwargs): return ifcopenshell.create_entity('IfcBridge', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBridgePart(*args, **kwargs): return ifcopenshell.create_entity('IfcBridgePart', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBuilding(*args, **kwargs): return ifcopenshell.create_entity('IfcBuilding', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBuildingElementPart(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPart', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBuildingElementPartType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPartType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBuildingElementProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxy', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBuildingElementProxyType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxyType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBuildingStorey(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingStorey', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBuildingSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingSystem', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBuiltElement(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBuiltElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBuiltSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltSystem', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBurner(*args, **kwargs): return ifcopenshell.create_entity('IfcBurner', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcBurnerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBurnerType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCShapeProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCableCarrierFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFitting', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCableCarrierFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFittingType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCableCarrierSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCableCarrierSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegmentType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCableFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFitting', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCableFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFittingType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCableSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCableSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegmentType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCaissonFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundation', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCaissonFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundationType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCartesianPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPoint', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCartesianPointList(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCartesianPointList2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList2D', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCartesianPointList3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList3D', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCartesianTransformationOperator(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCartesianTransformationOperator2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2D', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCartesianTransformationOperator2DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2DnonUniform', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCartesianTransformationOperator3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3D', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCartesianTransformationOperator3DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3DnonUniform', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCenterLineProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCenterLineProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcChiller(*args, **kwargs): return ifcopenshell.create_entity('IfcChiller', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcChillerType(*args, **kwargs): return ifcopenshell.create_entity('IfcChillerType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcChimney(*args, **kwargs): return ifcopenshell.create_entity('IfcChimney', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcChimneyType(*args, **kwargs): return ifcopenshell.create_entity('IfcChimneyType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCircle(*args, **kwargs): return ifcopenshell.create_entity('IfcCircle', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCircleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleHollowProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCircleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCircularArcSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCircularArcSegment2D', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCivilElement(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCivilElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcClassification', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcClassificationReference(*args, **kwargs): return ifcopenshell.create_entity('IfcClassificationReference', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcClosedShell(*args, **kwargs): return ifcopenshell.create_entity('IfcClosedShell', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCoil(*args, **kwargs): return ifcopenshell.create_entity('IfcCoil', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCoilType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoilType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcColourRgb(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgb', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcColourRgbList(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgbList', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcColourSpecification(*args, **kwargs): return ifcopenshell.create_entity('IfcColourSpecification', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcColumn', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcColumnStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnStandardCase', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcColumnType(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsAppliance', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsApplianceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcComplexProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexProperty', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcComplexPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexPropertyTemplate', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCompositeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCompositeCurveOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveOnSurface', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveSegment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCompositeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCompressor(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressor', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCompressorType(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressorType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCondenser(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenser', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCondenserType(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenserType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConic(*args, **kwargs): return ifcopenshell.create_entity('IfcConic', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConnectedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectedFaceSet', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConnectionCurveGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionCurveGeometry', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConnectionGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionGeometry', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConnectionPointEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointEccentricity', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConnectionPointGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointGeometry', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConnectionSurfaceGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionSurfaceGeometry', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConnectionVolumeGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionVolumeGeometry', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcConstraint', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConstructionEquipmentResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResource', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConstructionEquipmentResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResourceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConstructionMaterialResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResource', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConstructionMaterialResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResourceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConstructionProductResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResource', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConstructionProductResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResourceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConstructionResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResource', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConstructionResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResourceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcContext(*args, **kwargs): return ifcopenshell.create_entity('IfcContext', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcContextDependentUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcContextDependentUnit', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcControl(*args, **kwargs): return ifcopenshell.create_entity('IfcControl', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcController(*args, **kwargs): return ifcopenshell.create_entity('IfcController', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcControllerType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConversionBasedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnit', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConversionBasedUnitWithOffset(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnitWithOffset', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConveyorSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcConveyorSegment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcConveyorSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcConveyorSegmentType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCooledBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeam', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCooledBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeamType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCoolingTower(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTower', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCoolingTowerType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTowerType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCoordinateOperation(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateOperation', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCoordinateReferenceSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateReferenceSystem', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCostItem(*args, **kwargs): return ifcopenshell.create_entity('IfcCostItem', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCostSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcCostSchedule', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCostValue(*args, **kwargs): return ifcopenshell.create_entity('IfcCostValue', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCourse(*args, **kwargs): return ifcopenshell.create_entity('IfcCourse', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCourseType(*args, **kwargs): return ifcopenshell.create_entity('IfcCourseType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCovering(*args, **kwargs): return ifcopenshell.create_entity('IfcCovering', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCoveringType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoveringType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCrewResource(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResource', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCrewResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResourceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCsgPrimitive3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgPrimitive3D', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCsgSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgSolid', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCurrencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcCurrencyRelationship', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCurtainWall(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWall', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCurtainWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWallType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCurveBoundedPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedPlane', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCurveBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedSurface', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCurveSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveSegment2D', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCurveStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyle', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCurveStyleFont(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFont', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCurveStyleFontAndScaling(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontAndScaling', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCurveStyleFontPattern(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontPattern', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcCylindricalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCylindricalSurface', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcDamper', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcDamperType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDeepFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundation', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDeepFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundationType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDerivedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDerivedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnit', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDerivedUnitElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnitElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDimensionalExponents(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionalExponents', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDirection(*args, **kwargs): return ifcopenshell.create_entity('IfcDirection', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDirectrixCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcDirectrixCurveSweptAreaSolid', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDirectrixDistanceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcDirectrixDistanceSweptAreaSolid', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDiscreteAccessory(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessory', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDiscreteAccessoryType(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessoryType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDistanceExpression(*args, **kwargs): return ifcopenshell.create_entity('IfcDistanceExpression', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionBoard', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionBoardType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDistributionChamberElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDistributionChamberElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDistributionCircuit(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionCircuit', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDistributionControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDistributionControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDistributionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDistributionElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDistributionFlowElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDistributionFlowElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDistributionPort(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionPort', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDistributionSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionSystem', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDocumentInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformation', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDocumentInformationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformationRelationship', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDocumentReference(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentReference', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDoor(*args, **kwargs): return ifcopenshell.create_entity('IfcDoor', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDoorLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorLiningProperties', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDoorPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorPanelProperties', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDoorStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorStandardCase', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDoorStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorStyle', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDoorType(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDraughtingPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedColour', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDraughtingPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedCurveFont', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDuctFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFitting', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDuctFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFittingType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDuctSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDuctSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegmentType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDuctSilencer(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencer', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcDuctSilencerType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencerType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEarthworksCut(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksCut', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEarthworksElement(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEarthworksFill(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksFill', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcEdge', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEdgeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeCurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEdgeLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeLoop', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElectricAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricAppliance', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElectricApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricApplianceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElectricDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoard', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElectricDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoardType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElectricFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDevice', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElectricFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDeviceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElectricFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowTreatmentDevice', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElectricFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowTreatmentDeviceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElectricGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGenerator', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElectricGeneratorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGeneratorType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElectricMotor(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotor', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElectricMotorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotorType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElectricTimeControl(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControl', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElectricTimeControlType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControlType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElement(*args, **kwargs): return ifcopenshell.create_entity('IfcElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElementAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssembly', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElementAssemblyType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssemblyType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElementComponent(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponent', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElementComponentType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponentType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElementQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcElementQuantity', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcElementarySurface(*args, **kwargs): return ifcopenshell.create_entity('IfcElementarySurface', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEllipse(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipse', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEllipseProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipseProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEnergyConversionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDevice', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEnergyConversionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDeviceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEngine(*args, **kwargs): return ifcopenshell.create_entity('IfcEngine', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEngineType(*args, **kwargs): return ifcopenshell.create_entity('IfcEngineType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEvaporativeCooler(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCooler', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEvaporativeCoolerType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCoolerType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEvaporator(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporator', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEvaporatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporatorType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEvent(*args, **kwargs): return ifcopenshell.create_entity('IfcEvent', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEventTime(*args, **kwargs): return ifcopenshell.create_entity('IfcEventTime', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcEventType(*args, **kwargs): return ifcopenshell.create_entity('IfcEventType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcExtendedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcExtendedProperties', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcExternalInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalInformation', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcExternalReference(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReference', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcExternalReferenceRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReferenceRelationship', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcExternalSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcExternalSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialStructureElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcExternallyDefinedHatchStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedHatchStyle', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcExternallyDefinedSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedSurfaceStyle', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcExternallyDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedTextFont', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcExtrudedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolid', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcExtrudedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolidTapered', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFace(*args, **kwargs): return ifcopenshell.create_entity('IfcFace', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFaceBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBasedSurfaceModel', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFaceBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBound', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFaceOuterBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceOuterBound', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFaceSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceSurface', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFacetedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrep', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFacetedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrepWithVoids', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFacility(*args, **kwargs): return ifcopenshell.create_entity('IfcFacility', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFacilityPart(*args, **kwargs): return ifcopenshell.create_entity('IfcFacilityPart', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFailureConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcFailureConnectionCondition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFan(*args, **kwargs): return ifcopenshell.create_entity('IfcFan', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFanType(*args, **kwargs): return ifcopenshell.create_entity('IfcFanType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcFastener', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFastenerType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFeatureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFeatureElementAddition(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementAddition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFeatureElementSubtraction(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementSubtraction', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFillAreaStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyle', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFillAreaStyleHatching(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleHatching', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFillAreaStyleTiles(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleTiles', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFilter(*args, **kwargs): return ifcopenshell.create_entity('IfcFilter', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFilterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFilterType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFireSuppressionTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminal', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFireSuppressionTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminalType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFixedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcFixedReferenceSweptAreaSolid', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowController(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowController', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowControllerType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFitting', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFittingType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowInstrument(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrument', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowInstrumentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrumentType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowMeter(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeter', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowMeterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeterType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowMovingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDevice', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowMovingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDeviceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegmentType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDevice', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDeviceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminal', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminalType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDevice', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDeviceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFooting(*args, **kwargs): return ifcopenshell.create_entity('IfcFooting', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFootingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFootingType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFurnishingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFurnishingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFurniture(*args, **kwargs): return ifcopenshell.create_entity('IfcFurniture', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcFurnitureType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnitureType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGeographicElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGeographicElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGeometricCurveSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricCurveSet', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGeometricRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationContext', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGeometricRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationItem', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGeometricRepresentationSubContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationSubContext', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGeometricSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricSet', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGeomodel(*args, **kwargs): return ifcopenshell.create_entity('IfcGeomodel', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGeoslice(*args, **kwargs): return ifcopenshell.create_entity('IfcGeoslice', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGeotechnicalAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalAssembly', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGeotechnicalElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGeotechnicalStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalStratum', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGrid(*args, **kwargs): return ifcopenshell.create_entity('IfcGrid', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGridAxis(*args, **kwargs): return ifcopenshell.create_entity('IfcGridAxis', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGridPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcGridPlacement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcGroup', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcHalfSpaceSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcHalfSpaceSolid', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcHeatExchanger(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchanger', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcHeatExchangerType(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchangerType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcHumidifier(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifier', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcHumidifierType(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifierType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcIShapeProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcImageTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcImageTexture', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcImpactProtectionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcImpactProtectionDevice', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcImpactProtectionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcImpactProtectionDeviceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcInclinedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcInclinedReferenceSweptAreaSolid', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcIndexedColourMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedColourMap', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcIndexedPolyCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolyCurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcIndexedPolygonalFace(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFace', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcIndexedPolygonalFaceWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFaceWithVoids', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcIndexedTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTextureMap', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcIndexedTriangleTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTriangleTextureMap', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcInterceptor(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptor', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcInterceptorType(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptorType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcIntersectionCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIntersectionCurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcInventory(*args, **kwargs): return ifcopenshell.create_entity('IfcInventory', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcIrregularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeries', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcIrregularTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeriesValue', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcJunctionBox(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBox', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcJunctionBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBoxType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcKerb(*args, **kwargs): return ifcopenshell.create_entity('IfcKerb', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcKerbType(*args, **kwargs): return ifcopenshell.create_entity('IfcKerbType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcLShapeProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLaborResource(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResource', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLaborResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResourceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLagTime(*args, **kwargs): return ifcopenshell.create_entity('IfcLagTime', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLamp(*args, **kwargs): return ifcopenshell.create_entity('IfcLamp', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLampType(*args, **kwargs): return ifcopenshell.create_entity('IfcLampType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLibraryInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryInformation', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLibraryReference(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryReference', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLightDistributionData(*args, **kwargs): return ifcopenshell.create_entity('IfcLightDistributionData', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLightFixture(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixture', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLightFixtureType(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixtureType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLightIntensityDistribution(*args, **kwargs): return ifcopenshell.create_entity('IfcLightIntensityDistribution', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLightSource(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSource', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLightSourceAmbient(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceAmbient', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLightSourceDirectional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceDirectional', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLightSourceGoniometric(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceGoniometric', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLightSourcePositional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourcePositional', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLightSourceSpot(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceSpot', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLine(*args, **kwargs): return ifcopenshell.create_entity('IfcLine', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLineSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcLineSegment2D', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLinearAxisWithInclination(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearAxisWithInclination', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLinearPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPlacement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLinearPlacementWithInclination(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPlacementWithInclination', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLinearPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPositioningElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLinearSpanPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearSpanPlacement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLiquidTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcLiquidTerminal', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLiquidTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcLiquidTerminalType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLocalPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLocalPlacement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcLoop', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcManifoldSolidBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcManifoldSolidBrep', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMapConversion(*args, **kwargs): return ifcopenshell.create_entity('IfcMapConversion', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMappedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcMappedItem', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMarineFacility(*args, **kwargs): return ifcopenshell.create_entity('IfcMarineFacility', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterial', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialClassificationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialClassificationRelationship', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialConstituent(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituent', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialConstituentSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituentSet', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialDefinitionRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinitionRepresentation', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialLayer(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayer', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialLayerSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSet', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialLayerSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSetUsage', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialLayerWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerWithOffsets', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialList(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialList', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialProfile(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfile', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialProfileSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSet', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialProfileSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsage', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialProfileSetUsageTapering(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsageTapering', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialProfileWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileWithOffsets', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProperties', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialRelationship', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMaterialUsageDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialUsageDefinition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMeasureWithUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMeasureWithUnit', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMechanicalFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastener', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMechanicalFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastenerType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMedicalDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDevice', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMedicalDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDeviceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMember(*args, **kwargs): return ifcopenshell.create_entity('IfcMember', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMemberStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberStandardCase', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMemberType(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMetric(*args, **kwargs): return ifcopenshell.create_entity('IfcMetric', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMirroredProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcMirroredProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMobileTelecommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcMobileTelecommunicationsAppliance', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMobileTelecommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMobileTelecommunicationsApplianceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMonetaryUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMonetaryUnit', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMooringDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMooringDevice', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMooringDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMooringDeviceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMotorConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnection', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcMotorConnectionType(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnectionType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcNamedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcNamedUnit', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcNavigationElement(*args, **kwargs): return ifcopenshell.create_entity('IfcNavigationElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcNavigationElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcNavigationElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcObject(*args, **kwargs): return ifcopenshell.create_entity('IfcObject', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcObjectDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectDefinition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcObjectPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectPlacement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcObjective(*args, **kwargs): return ifcopenshell.create_entity('IfcObjective', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOccupant(*args, **kwargs): return ifcopenshell.create_entity('IfcOccupant', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOffsetCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOffsetCurve2D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve2D', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOffsetCurve3D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve3D', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOffsetCurveByDistances(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurveByDistances', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOpenCrossProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenCrossProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOpenShell(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenShell', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOpeningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOpeningStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningStandardCase', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganization', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOrganizationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganizationRelationship', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOrientationExpression(*args, **kwargs): return ifcopenshell.create_entity('IfcOrientationExpression', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOrientedEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcOrientedEdge', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOuterBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOuterBoundaryCurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOutlet(*args, **kwargs): return ifcopenshell.create_entity('IfcOutlet', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOutletType(*args, **kwargs): return ifcopenshell.create_entity('IfcOutletType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcOwnerHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcOwnerHistory', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcParameterizedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcParameterizedProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPath(*args, **kwargs): return ifcopenshell.create_entity('IfcPath', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPavement(*args, **kwargs): return ifcopenshell.create_entity('IfcPavement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPavementType(*args, **kwargs): return ifcopenshell.create_entity('IfcPavementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPcurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPcurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPerformanceHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcPerformanceHistory', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPermeableCoveringProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPermeableCoveringProperties', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPermit(*args, **kwargs): return ifcopenshell.create_entity('IfcPermit', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPerson(*args, **kwargs): return ifcopenshell.create_entity('IfcPerson', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPersonAndOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcPersonAndOrganization', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPhysicalComplexQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalComplexQuantity', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPhysicalQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalQuantity', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPhysicalSimpleQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalSimpleQuantity', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPile(*args, **kwargs): return ifcopenshell.create_entity('IfcPile', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPileType(*args, **kwargs): return ifcopenshell.create_entity('IfcPileType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPipeFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFitting', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPipeFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFittingType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPipeSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPipeSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegmentType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPixelTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcPixelTexture', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcPlacement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPlanarBox(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarBox', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPlanarExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarExtent', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcPlane', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPlant(*args, **kwargs): return ifcopenshell.create_entity('IfcPlant', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPlate(*args, **kwargs): return ifcopenshell.create_entity('IfcPlate', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPlateStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateStandardCase', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPlateType(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcPoint', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPointOnCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnCurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPointOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnSurface', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPolyLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyLoop', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPolygonalBoundedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalBoundedHalfSpace', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPolygonalFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalFaceSet', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPolyline(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyline', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPort(*args, **kwargs): return ifcopenshell.create_entity('IfcPort', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcPositioningElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPostalAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcPostalAddress', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedColour', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedCurveFont', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPreDefinedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedItem', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPreDefinedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedProperties', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPreDefinedPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedPropertySet', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPreDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedTextFont', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationItem', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPresentationLayerAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerAssignment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPresentationLayerWithStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerWithStyle', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPresentationStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyle', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPresentationStyleAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyleAssignment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProcedure(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedure', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProcedureType(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedureType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcProcess', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcProduct', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProductDefinitionShape(*args, **kwargs): return ifcopenshell.create_entity('IfcProductDefinitionShape', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProductRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcProductRepresentation', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileProperties', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProject(*args, **kwargs): return ifcopenshell.create_entity('IfcProject', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProjectLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectLibrary', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProjectOrder(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectOrder', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProjectedCRS(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectedCRS', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProjectionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectionElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcProperty', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPropertyAbstraction(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyAbstraction', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPropertyBoundedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyBoundedValue', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPropertyDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDefinition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPropertyDependencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDependencyRelationship', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPropertyEnumeratedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeratedValue', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPropertyEnumeration(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeration', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPropertyListValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyListValue', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPropertyReferenceValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyReferenceValue', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySet', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPropertySetDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetDefinition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPropertySetTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetTemplate', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPropertySingleValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySingleValue', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPropertyTableValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTableValue', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplate', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPropertyTemplateDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplateDefinition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProtectiveDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDevice', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnit', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnitType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnitType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProtectiveDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcProxy', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPump(*args, **kwargs): return ifcopenshell.create_entity('IfcPump', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcPumpType(*args, **kwargs): return ifcopenshell.create_entity('IfcPumpType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcQuantityArea(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityArea', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcQuantityCount(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityCount', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcQuantityLength(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityLength', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcQuantitySet(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantitySet', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcQuantityTime(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityTime', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcQuantityVolume(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityVolume', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcQuantityWeight(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityWeight', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRail(*args, **kwargs): return ifcopenshell.create_entity('IfcRail', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRailType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRailing(*args, **kwargs): return ifcopenshell.create_entity('IfcRailing', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRailingType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailingType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRailway(*args, **kwargs): return ifcopenshell.create_entity('IfcRailway', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRamp(*args, **kwargs): return ifcopenshell.create_entity('IfcRamp', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRampFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlight', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRampFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlightType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRampType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRationalBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineCurveWithKnots', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRationalBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineSurfaceWithKnots', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRectangleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleHollowProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRectangularPyramid(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularPyramid', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRectangularTrimmedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularTrimmedSurface', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRecurrencePattern(*args, **kwargs): return ifcopenshell.create_entity('IfcRecurrencePattern', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcReference(*args, **kwargs): return ifcopenshell.create_entity('IfcReference', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcReferent(*args, **kwargs): return ifcopenshell.create_entity('IfcReferent', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRegularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcRegularTimeSeries', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcReinforcedSoil(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcedSoil', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcReinforcementBarProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementBarProperties', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcReinforcementDefinitionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementDefinitionProperties', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcReinforcingBar(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBar', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcReinforcingBarType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBarType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcReinforcingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcReinforcingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcReinforcingMesh(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMesh', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcReinforcingMeshType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMeshType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAggregates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAggregates', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssigns(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssigns', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssignsToActor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToActor', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssignsToControl(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToControl', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssignsToGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroup', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssignsToGroupByFactor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroupByFactor', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssignsToProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProcess', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssignsToProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProduct', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssignsToResource(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToResource', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssociates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociates', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssociatesApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesApproval', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssociatesClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesClassification', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssociatesConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesConstraint', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssociatesDocument(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesDocument', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssociatesLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesLibrary', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssociatesMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesMaterial', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelAssociatesProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelConnects(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnects', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelConnectsElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsElements', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelConnectsPathElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPathElements', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelConnectsPortToElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPortToElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelConnectsPorts(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPorts', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelConnectsStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralActivity', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelConnectsStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralMember', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelConnectsWithEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithEccentricity', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelConnectsWithRealizingElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithRealizingElements', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelContainedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelContainedInSpatialStructure', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelCoversBldgElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversBldgElements', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelCoversSpaces(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversSpaces', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelDeclares(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDeclares', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelDecomposes(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDecomposes', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelDefines(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefines', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelDefinesByObject(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByObject', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelDefinesByProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByProperties', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelDefinesByTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByTemplate', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelDefinesByType(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelFillsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFillsElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelFlowControlElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFlowControlElements', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelInterferesElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelInterferesElements', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelNests(*args, **kwargs): return ifcopenshell.create_entity('IfcRelNests', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelPositions(*args, **kwargs): return ifcopenshell.create_entity('IfcRelPositions', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelProjectsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelProjectsElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelReferencedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelReferencedInSpatialStructure', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelSequence(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSequence', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelServicesBuildings(*args, **kwargs): return ifcopenshell.create_entity('IfcRelServicesBuildings', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelSpaceBoundary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelSpaceBoundary1stLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary1stLevel', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelSpaceBoundary2ndLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary2ndLevel', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelVoidsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelVoidsElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcRelationship', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcReparametrisedCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcReparametrisedCompositeCurveSegment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentation', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationContext', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationItem', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRepresentationMap(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationMap', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcResource(*args, **kwargs): return ifcopenshell.create_entity('IfcResource', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcResourceApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceApprovalRelationship', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcResourceConstraintRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceConstraintRelationship', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcResourceLevelRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceLevelRelationship', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcResourceTime(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceTime', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRevolvedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolid', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRevolvedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolidTapered', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRightCircularCone(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCone', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRightCircularCylinder(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCylinder', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRoad(*args, **kwargs): return ifcopenshell.create_entity('IfcRoad', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRoof(*args, **kwargs): return ifcopenshell.create_entity('IfcRoof', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRoofType(*args, **kwargs): return ifcopenshell.create_entity('IfcRoofType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRoot(*args, **kwargs): return ifcopenshell.create_entity('IfcRoot', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcRoundedRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRoundedRectangleProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSIUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcSIUnit', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSanitaryTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminal', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSanitaryTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminalType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSchedulingTime(*args, **kwargs): return ifcopenshell.create_entity('IfcSchedulingTime', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSeamCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSeamCurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSectionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionProperties', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSectionReinforcementProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionReinforcementProperties', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSectionedSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolid', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSectionedSolidHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolidHorizontal', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSectionedSpine(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSpine', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSectionedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSurface', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSensor(*args, **kwargs): return ifcopenshell.create_entity('IfcSensor', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSensorType(*args, **kwargs): return ifcopenshell.create_entity('IfcSensorType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcShadingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDevice', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcShadingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDeviceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcShapeAspect(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeAspect', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcShapeModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeModel', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcShapeRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeRepresentation', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcShellBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShellBasedSurfaceModel', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSign(*args, **kwargs): return ifcopenshell.create_entity('IfcSign', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSignType(*args, **kwargs): return ifcopenshell.create_entity('IfcSignType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSignal(*args, **kwargs): return ifcopenshell.create_entity('IfcSignal', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSignalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSignalType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSimpleProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcSimpleProperty', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSimplePropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcSimplePropertyTemplate', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSite(*args, **kwargs): return ifcopenshell.create_entity('IfcSite', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSlab(*args, **kwargs): return ifcopenshell.create_entity('IfcSlab', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSlabElementedCase(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabElementedCase', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSlabStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabStandardCase', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSlabType(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSlippageConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcSlippageConnectionCondition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSolarDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDevice', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSolarDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDeviceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSolidModel(*args, **kwargs): return ifcopenshell.create_entity('IfcSolidModel', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSolidStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcSolidStratum', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcSpace', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSpaceHeater(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeater', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSpaceHeaterType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeaterType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSpaceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSpatialElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSpatialStructureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSpatialZone(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZone', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSpatialZoneType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZoneType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSphere(*args, **kwargs): return ifcopenshell.create_entity('IfcSphere', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSphericalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSphericalSurface', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStackTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminal', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStackTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminalType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStair(*args, **kwargs): return ifcopenshell.create_entity('IfcStair', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStairFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlight', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStairFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlightType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStairType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAction', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralActivity', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralAnalysisModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAnalysisModel', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnection', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnectionCondition', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralCurveAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveAction', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralCurveConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveConnection', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralCurveMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMember', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralCurveMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMemberVarying', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralCurveReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveReaction', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralItem', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralLinearAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLinearAction', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralLoad(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoad', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralLoadCase(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadCase', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralLoadConfiguration(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadConfiguration', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralLoadGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadGroup', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralLoadLinearForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadLinearForce', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralLoadOrResult(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadOrResult', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralLoadPlanarForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadPlanarForce', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacement(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacementDistortion(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacementDistortion', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralLoadSingleForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForce', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralLoadSingleForceWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForceWarping', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralLoadStatic(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadStatic', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralLoadTemperature(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadTemperature', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralMember', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralPlanarAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPlanarAction', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralPointAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointAction', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralPointConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointConnection', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralPointReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointReaction', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralReaction', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralResultGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralResultGroup', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralSurfaceAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceAction', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralSurfaceConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceConnection', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralSurfaceMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMember', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralSurfaceMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMemberVarying', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStructuralSurfaceReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceReaction', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStyleModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStyleModel', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStyledItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledItem', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcStyledRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledRepresentation', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSubContractResource(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResource', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSubContractResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResourceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSubedge(*args, **kwargs): return ifcopenshell.create_entity('IfcSubedge', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSurface', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSurfaceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSurfaceCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurveSweptAreaSolid', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSurfaceFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceFeature', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSurfaceOfLinearExtrusion(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfLinearExtrusion', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSurfaceOfRevolution(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfRevolution', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSurfaceReinforcementArea(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceReinforcementArea', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyle', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSurfaceStyleLighting(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleLighting', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSurfaceStyleRefraction(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRefraction', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSurfaceStyleRendering(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRendering', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSurfaceStyleShading(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleShading', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSurfaceStyleWithTextures(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleWithTextures', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSurfaceTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceTexture', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptAreaSolid', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSweptDiskSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolid', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSweptDiskSolidPolygonal(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolidPolygonal', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSweptSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptSurface', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSwitchingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDevice', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSwitchingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDeviceType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcSystem', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSystemFurnitureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcSystemFurnitureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTShapeProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTable(*args, **kwargs): return ifcopenshell.create_entity('IfcTable', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTableColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcTableColumn', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTableRow(*args, **kwargs): return ifcopenshell.create_entity('IfcTableRow', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTank(*args, **kwargs): return ifcopenshell.create_entity('IfcTank', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTankType(*args, **kwargs): return ifcopenshell.create_entity('IfcTankType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTask(*args, **kwargs): return ifcopenshell.create_entity('IfcTask', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTaskTime(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTime', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTaskTimeRecurring(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTimeRecurring', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTaskType(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTelecomAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcTelecomAddress', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTendon(*args, **kwargs): return ifcopenshell.create_entity('IfcTendon', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTendonAnchor(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchor', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTendonAnchorType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchorType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTendonConduit(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduit', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTendonConduitType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduitType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTendonType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTessellatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedFaceSet', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTessellatedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedItem', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTextLiteral(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteral', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTextLiteralWithExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteralWithExtent', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTextStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyle', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTextStyleFontModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleFontModel', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTextStyleForDefinedFont(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleForDefinedFont', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTextStyleTextModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleTextModel', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTextureCoordinate(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinate', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTextureCoordinateGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateGenerator', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureMap', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTextureVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertex', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTextureVertexList(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertexList', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTimePeriod(*args, **kwargs): return ifcopenshell.create_entity('IfcTimePeriod', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeries', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeriesValue', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTopologicalRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologicalRepresentationItem', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTopologyRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologyRepresentation', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcToroidalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcToroidalSurface', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTrackElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTrackElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTrackElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTrackElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTransformer(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformer', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTransformerType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformerType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTransitionCurveSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcTransitionCurveSegment2D', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTransportElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTransportElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTrapeziumProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTrapeziumProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTriangulatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedFaceSet', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTriangulatedIrregularNetwork(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedIrregularNetwork', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTrimmedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcTrimmedCurve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTubeBundle(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundle', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTubeBundleType(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundleType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTypeObject(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeObject', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTypeProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProcess', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTypeProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProduct', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcTypeResource(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeResource', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcUShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcUShapeProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcUnitAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitAssignment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcUnitaryControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcUnitaryControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElementType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcUnitaryEquipment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipment', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcUnitaryEquipmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipmentType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcValve(*args, **kwargs): return ifcopenshell.create_entity('IfcValve', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcValveType(*args, **kwargs): return ifcopenshell.create_entity('IfcValveType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcVector(*args, **kwargs): return ifcopenshell.create_entity('IfcVector', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcVertex', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcVertexLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexLoop', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcVertexPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexPoint', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcVibrationDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamper', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcVibrationDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamperType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcVibrationIsolator(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolator', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcVibrationIsolatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolatorType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcVirtualElement(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualElement', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcVirtualGridIntersection(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualGridIntersection', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcVoidStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcVoidStratum', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcVoidingFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcVoidingFeature', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWall(*args, **kwargs): return ifcopenshell.create_entity('IfcWall', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWallElementedCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallElementedCase', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWallStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallStandardCase', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcWallType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWasteTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminal', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWasteTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminalType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWaterStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcWaterStratum', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWindow(*args, **kwargs): return ifcopenshell.create_entity('IfcWindow', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWindowLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowLiningProperties', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWindowPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowPanelProperties', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWindowStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowStandardCase', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWindowStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowStyle', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWindowType(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowType', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWorkCalendar(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkCalendar', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWorkControl(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkControl', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWorkPlan(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkPlan', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWorkSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkSchedule', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcWorkTime(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkTime', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcZShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcZShapeProfileDef', 'IFC4X3_RC1', *args, **kwargs) + + +def IfcZone(*args, **kwargs): return ifcopenshell.create_entity('IfcZone', 'IFC4X3_RC1', *args, **kwargs) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcBoxAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcBoxAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['top-left','top-middle','top-right','middle-left','center','middle-right','bottom-left','bottom-middle','bottom-right'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCardinalPointReference_GreaterThanZero: + SCOPE = "type" + TYPE_NAME = "IfcCardinalPointReference" + RULE_NAME = "GreaterThanZero" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCompoundPlaneAngleMeasure_MinutesInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MinutesInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[2 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_SecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "SecondsInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[3 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_MicrosecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MicrosecondsInRange" + + @staticmethod + def __call__(self): + + + assert (sizeof(self) == 3) or ((abs(self[4 - 1])) < 1000000) + + + + +class IfcCompoundPlaneAngleMeasure_ConsistentSign: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "ConsistentSign" + + @staticmethod + def __call__(self): + + + assert (((self[1 - 1]) >= 0) and ((self[2 - 1]) >= 0) and ((self[3 - 1]) >= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) >= 0))) or (((self[1 - 1]) <= 0) and ((self[2 - 1]) <= 0) and ((self[3 - 1]) <= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) <= 0))) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDayInMonthNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInMonthNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 31 + + + + + +class IfcDayInWeekNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInWeekNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 7 + + + + + + + + + + + + + + + + + +class IfcDimensionCount_WR1: + SCOPE = "type" + TYPE_NAME = "IfcDimensionCount" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0 < self <= 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFontStyle_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontStyle" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','italic','oblique'] + + + + + +class IfcFontVariant_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontVariant" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps'] + + + + + +class IfcFontWeight_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontWeight" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps','100','200','300','400','500','600','700','800','900'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcHeatingValueMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcHeatingValueMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMonthInYearNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcMonthInYearNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 12 + + + + + + + + + + + + + + +class IfcNonNegativeLengthMeasure_NotNegative: + SCOPE = "type" + TYPE_NAME = "IfcNonNegativeLengthMeasure" + RULE_NAME = "NotNegative" + + @staticmethod + def __call__(self): + + + assert self >= 0. + + + + + +class IfcNormalisedRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcNormalisedRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPHMeasure_WR21: + SCOPE = "type" + TYPE_NAME = "IfcPHMeasure" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 14.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPositiveInteger_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveInteger" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + +class IfcPositiveLengthMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveLengthMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositivePlaneAngleMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositivePlaneAngleMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositiveRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcSpecularRoughness_WR1: + SCOPE = "type" + TYPE_NAME = "IfcSpecularRoughness" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTextAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['left','right','center','justify'] + + + + + +class IfcTextDecoration_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextDecoration" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['none','underline','overline','line-through','blink'] + + + + + + + + + + + + + + +class IfcTextTransformation_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextTransformation" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['capitalize','uppercase','lowercase','none'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcActorRole_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcActorRole" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + role = self.Role + + assert (role != IfcRoleEnum.USERDEFINED) or ((role == IfcRoleEnum.USERDEFINED) and exists(self.UserDefinedRole)) + + + + + +class IfcActuator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcActuator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcactuatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcActuatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + purpose = self.Purpose + + assert (not exists(purpose)) or ((purpose != IfcAddressTypeEnum.USERDEFINED) or ((purpose == IfcAddressTypeEnum.USERDEFINED) and exists(self.UserDefinedPurpose))) + + + + + +class IfcAdvancedBrep_HasAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrep" + RULE_NAME = "HasAdvancedFaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([afs for afs in self.Outer.CfsFaces if not 'ifc4x3_rc1.ifcadvancedface' in typeof(afs)])) == 0 + + + + + +class IfcAdvancedBrepWithVoids_VoidsHaveAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrepWithVoids" + RULE_NAME = "VoidsHaveAdvancedFaces" + + @staticmethod + def __call__(self): + voids = self.Voids + + assert (sizeof([vsh for vsh in voids if (sizeof([afs for afs in vsh.CfsFaces if not 'ifc4x3_rc1.ifcadvancedface' in typeof(afs)])) == 0])) == 0 + + + + + +class IfcAdvancedFace_ApplicableSurface: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableSurface" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc1.ifcelementarysurface','ifc4x3_rc1.ifcsweptsurface','ifc4x3_rc1.ifcbsplinesurface'] * typeof(self.FaceSurface))) == 1 + + + + +class IfcAdvancedFace_RequiresEdgeCurve: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "RequiresEdgeCurve" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x3_rc1.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not 'ifc4x3_rc1.ifcedgecurve' in typeof(oe.EdgeElement)])) == 0])) == 0 + + + + +class IfcAdvancedFace_ApplicableEdgeCurves: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableEdgeCurves" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x3_rc1.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not (sizeof(['ifc4x3_rc1.ifcline','ifc4x3_rc1.ifcconic','ifc4x3_rc1.ifcpolyline','ifc4x3_rc1.ifcbsplinecurve'] * typeof(oe.EdgeElement.EdgeGeometry))) == 1])) == 0])) == 0 + + + + + +class IfcAirTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcairterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminalBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcairterminalboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirToAirHeatRecovery_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirToAirHeatRecovery_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcairtoairheatrecoverytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirToAirHeatRecoveryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecoveryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAlarm_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAlarm_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcalarmtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAlarmType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarmType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcApproval_HasIdentifierOrName: + SCOPE = "entity" + TYPE_NAME = "IfcApproval" + RULE_NAME = "HasIdentifierOrName" + + @staticmethod + def __call__(self): + identifier = self.Identifier + name = self.Name + + assert exists(identifier) or exists(name) + + + + + + + + +class IfcArbitraryClosedProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert outercurve.Dim == 2 + + + + +class IfcArbitraryClosedProfileDef_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x3_rc1.ifcline' in typeof(outercurve) + + + + +class IfcArbitraryClosedProfileDef_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x3_rc1.ifcoffsetcurve2d' in typeof(outercurve) + + + + + +class IfcArbitraryOpenProfileDef_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_rc1.ifccenterlineprofiledef' in typeof(self)) or (self.ProfileType == IfcProfileTypeEnum.CURVE) + + + + +class IfcArbitraryOpenProfileDef_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + curve = self.Curve + + assert curve.Dim == 2 + + + + + +class IfcArbitraryProfileDefWithVoids_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == area + + + + +class IfcArbitraryProfileDefWithVoids_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if temp.Dim != 2])) == 0 + + + + +class IfcArbitraryProfileDefWithVoids_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if 'ifc4x3_rc1.ifcline' in typeof(temp)])) == 0 + + + + + + + + +class IfcAsymmetricIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + bottomflangethickness = self.BottomFlangeThickness + topflangethickness = self.TopFlangeThickness + + assert (not exists(topflangethickness)) or ((bottomflangethickness + topflangethickness) < overalldepth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + + assert (webthickness < bottomflangewidth) and (webthickness < topflangewidth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidBottomFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidBottomFilletRadius" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + bottomflangefilletradius = self.BottomFlangeFilletRadius + + assert (not exists(bottomflangefilletradius)) or (bottomflangefilletradius <= ((bottomflangewidth - webthickness) / 2.)) + + + + +class IfcAsymmetricIShapeProfileDef_ValidTopFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidTopFilletRadius" + + @staticmethod + def __call__(self): + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + topflangefilletradius = self.TopFlangeFilletRadius + + assert (not exists(topflangefilletradius)) or (topflangefilletradius <= ((topflangewidth - webthickness) / 2.)) + + + + + +class IfcAudioVisualAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAudioVisualAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcaudiovisualappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAudioVisualApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAxis1Placement_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis1Placement_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +def calc_IfcAxis1Placement_Z(self): + axis = self.Axis + return \ + nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + + + + +class IfcAxis2Placement2D_RefDirIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "RefDirIs2D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 2) + + + + +class IfcAxis2Placement2D_LocationIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIs2D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 2 + + + + +def calc_IfcAxis2Placement2D_P(self): + refdirection = self.RefDirection + return \ + IfcBuild2Axes(refdirection) + + + + +class IfcAxis2Placement3D_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis2Placement3D_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis2Placement3D_RefDirIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "RefDirIs3D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 3) + + + + +class IfcAxis2Placement3D_AxisToRefDirPosition: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisToRefDirPosition" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + +class IfcAxis2Placement3D_AxisAndRefDirProvision: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisAndRefDirProvision" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert not exists(axis) ^ exists(refdirection) + + + + +def calc_IfcAxis2Placement3D_P(self): + axis = self.Axis + refdirection = self.RefDirection + return \ + IfcBuildAxes(axis,refdirection) + + + + + + + +class IfcBSplineCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + controlpointslist = self.ControlPointsList + + assert (sizeof([temp for temp in controlpointslist if temp.Dim != (controlpointslist[1 - 1].Dim)])) == 0 + + + + +def calc_IfcBSplineCurve_UpperIndexOnControlPoints(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineCurve_ControlPoints(self): + controlpointslist = self.ControlPointsList + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + return \ + IfcListToArray(controlpointslist,0,upperindexoncontrolpoints) + + + + +class IfcBSplineCurveWithKnots_ConsistentBSpline: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "ConsistentBSpline" + + @staticmethod + def __call__(self): + degree = self.Degree + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + knotmultiplicities = self.KnotMultiplicities + knots = self.Knots + upperindexonknots = self.UpperIndexOnKnots + + assert IfcConstraintsParamBSpline(degree,upperindexonknots,upperindexoncontrolpoints,knotmultiplicities,knots) + + + + +class IfcBSplineCurveWithKnots_CorrespondingKnotLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "CorrespondingKnotLists" + + @staticmethod + def __call__(self): + knotmultiplicities = self.KnotMultiplicities + upperindexonknots = self.UpperIndexOnKnots + + assert sizeof(knotmultiplicities) == upperindexonknots + + + + +def calc_IfcBSplineCurveWithKnots_UpperIndexOnKnots(self): + knots = self.Knots + return \ + sizeof(knots) + + + + +def calc_IfcBSplineSurface_UUpper(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineSurface_VUpper(self): + controlpointslist = self.ControlPointsList + return \ + (sizeof(controlpointslist[1 - 1])) - 1 + + + +def calc_IfcBSplineSurface_ControlPoints(self): + controlpointslist = self.ControlPointsList + uupper = self.UUpper + vupper = self.VUpper + return \ + IfcMakeArrayOfArray(controlpointslist,0,uupper,0,vupper) + + + + +class IfcBSplineSurfaceWithKnots_UDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "UDirectionConstraints" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + uknots = self.UKnots + knotuupper = self.KnotUUpper + + assert IfcConstraintsParamBSpline(self.UDegree,knotuupper,self.UUpper,umultiplicities,uknots) + + + + +class IfcBSplineSurfaceWithKnots_VDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "VDirectionConstraints" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + vknots = self.VKnots + knotvupper = self.KnotVUpper + + assert IfcConstraintsParamBSpline(self.VDegree,knotvupper,self.VUpper,vmultiplicities,vknots) + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingULists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingULists" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + knotuupper = self.KnotUUpper + + assert sizeof(umultiplicities) == knotuupper + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingVLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingVLists" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + knotvupper = self.KnotVUpper + + assert sizeof(vmultiplicities) == knotvupper + + + + +def calc_IfcBSplineSurfaceWithKnots_KnotVUpper(self): + vknots = self.VKnots + return \ + sizeof(vknots) + + + +def calc_IfcBSplineSurfaceWithKnots_KnotUUpper(self): + uknots = self.UKnots + return \ + sizeof(uknots) + + + + +class IfcBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBeamStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcBeamStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc1.ifcrelassociates.relatedobjects') if ('ifc4x3_rc1.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc1.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBearing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBearing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcbearingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBearingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBlobTexture_SupportedRasterFormat: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "SupportedRasterFormat" + + @staticmethod + def __call__(self): + + + assert self.RasterFormat in ['bmp','jpg','gif','png'] + + + + +class IfcBlobTexture_RasterCodeByteStream: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "RasterCodeByteStream" + + @staticmethod + def __call__(self): + rastercode = self.RasterCode + + assert (blength(rastercode) % 8) == 0 + + + + + + + + +class IfcBoiler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBoiler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcboilertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBoilerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoilerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBooleanClippingResult_FirstOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "FirstOperandType" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert ('ifc4x3_rc1.ifcsweptareasolid' in typeof(firstoperand)) or ('ifc4x3_rc1.ifcsweptdiscsolid' in typeof(firstoperand)) or ('ifc4x3_rc1.ifcbooleanclippingresult' in typeof(firstoperand)) + + + + +class IfcBooleanClippingResult_SecondOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "SecondOperandType" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert 'ifc4x3_rc1.ifchalfspacesolid' in typeof(secondoperand) + + + + +class IfcBooleanClippingResult_OperatorType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "OperatorType" + + @staticmethod + def __call__(self): + operator = self.Operator + + assert operator == difference + + + + + +class IfcBooleanResult_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + secondoperand = self.SecondOperand + + assert firstoperand.Dim == secondoperand.Dim + + + + +class IfcBooleanResult_FirstOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "FirstOperandClosed" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert (not 'ifc4x3_rc1.ifctessellatedfaceset' in typeof(firstoperand)) or (exists(firstoperand.Closed) and firstoperand.Closed) + + + + +class IfcBooleanResult_SecondOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SecondOperandClosed" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert (not 'ifc4x3_rc1.ifctessellatedfaceset' in typeof(secondoperand)) or (exists(secondoperand.Closed) and secondoperand.Closed) + + + + +def calc_IfcBooleanResult_Dim(self): + firstoperand = self.FirstOperand + return \ + firstoperand.Dim + + + + + + + + + + +class IfcBoundaryCurve_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBoundaryCurve" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + + + assert self.ClosedCurve + + + + + + + + + + + + + + + + + + + + + + + +def calc_IfcBoundingBox_Dim(self): + + return \ + 3 + + + + +class IfcBoxedHalfSpace_UnboundedSurface: + SCOPE = "entity" + TYPE_NAME = "IfcBoxedHalfSpace" + RULE_NAME = "UnboundedSurface" + + @staticmethod + def __call__(self): + + + assert not 'ifc4x3_rc1.ifccurveboundedplane' in typeof(self.BaseSurface) + + + + + + + + + + + + + + +class IfcBuildingElementPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementPart_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcbuildingelementparttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementPartType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPartType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBuildingElementProxy_HasObjectName: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "HasObjectName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcBuildingElementProxy_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementProxy_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcbuildingelementproxytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementProxyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcBuiltElement_MaxOneMaterialAssociation: + SCOPE = "entity" + TYPE_NAME = "IfcBuiltElement" + RULE_NAME = "MaxOneMaterialAssociation" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.HasAssociations if 'ifc4x3_rc1.ifcrelassociatesmaterial' in typeof(temp)])) <= 1 + + + + + + + + +class IfcBuiltSystem_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuiltSystem" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuiltSystemTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuiltSystemTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcBurner_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBurner_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcburnertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBurnerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurnerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCShapeProfileDef_ValidGirth: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidGirth" + + @staticmethod + def __call__(self): + depth = self.Depth + girth = self.Girth + + assert girth < (depth / 2.) + + + + +class IfcCShapeProfileDef_ValidInternalFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidInternalFilletRadius" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + internalfilletradius = self.InternalFilletRadius + + assert (not exists(internalfilletradius)) or ((internalfilletradius <= ((width / 2.) - wallthickness)) and (internalfilletradius <= ((depth / 2.) - wallthickness))) + + + + +class IfcCShapeProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + + assert (wallthickness < (width / 2.)) and (wallthickness < (depth / 2.)) + + + + + +class IfcCableCarrierFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccablecarrierfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableCarrierSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccablecarriersegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccablefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccablesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCaissonFoundation_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCaissonFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccaissonfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCaissonFoundationType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundationType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCartesianPoint_CP2Dor3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianPoint" + RULE_NAME = "CP2Dor3D" + + @staticmethod + def __call__(self): + coordinates = self.Coordinates + + assert hiindex(coordinates) >= 2 + + + + +def calc_IfcCartesianPoint_Dim(self): + coordinates = self.Coordinates + return \ + hiindex(coordinates) + + + + +def calc_IfcCartesianPointList_Dim(self): + + return \ + IfcPointListDim(self) + + + + + + + + + + +class IfcCartesianTransformationOperator_ScaleGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator" + RULE_NAME = "ScaleGreaterZero" + + @staticmethod + def __call__(self): + scl = self.Scl + + assert scl > 0.0 + + + + +def calc_IfcCartesianTransformationOperator_Scl(self): + scale = self.Scale + return \ + nvl(scale,1.0) + + + +def calc_IfcCartesianTransformationOperator_Dim(self): + localorigin = self.LocalOrigin + return \ + localorigin.Dim + + + + +class IfcCartesianTransformationOperator2D_DimEqual2: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "DimEqual2" + + @staticmethod + def __call__(self): + + + assert self.Dim == 2 + + + + +class IfcCartesianTransformationOperator2D_Axis1Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis1Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 2) + + + + +class IfcCartesianTransformationOperator2D_Axis2Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis2Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 2) + + + + +def calc_IfcCartesianTransformationOperator2D_U(self): + + return \ + IfcBaseAxis(2,self.Axis1,self.Axis2,None) + + + + +class IfcCartesianTransformationOperator2DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator2DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + + +class IfcCartesianTransformationOperator3D_DimIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "DimIs3D" + + @staticmethod + def __call__(self): + + + assert self.Dim == 3 + + + + +class IfcCartesianTransformationOperator3D_Axis1Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis1Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis2Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis2Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis3Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis3Is3D" + + @staticmethod + def __call__(self): + axis3 = self.Axis3 + + assert (not exists(axis3)) or (axis3.Dim == 3) + + + + +def calc_IfcCartesianTransformationOperator3D_U(self): + axis3 = self.Axis3 + return \ + IfcBaseAxis(3,self.Axis1,self.Axis2,axis3) + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale3GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale3GreaterZero" + + @staticmethod + def __call__(self): + scl3 = self.Scl3 + + assert scl3 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl3(self): + scale3 = self.Scale3 + return \ + nvl(scale3,self.Scl) + + + + + + + +class IfcChiller_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChiller_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcchillertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChillerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChillerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcChimney_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChimney_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcchimneytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChimneyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimneyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcCircleHollowProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCircleHollowProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert wallthickness < self.Radius + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoil_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccoiltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoilType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoilType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcColumn_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcColumn_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccolumntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcColumnStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcColumnStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc1.ifcrelassociates.relatedobjects') if ('ifc4x3_rc1.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc1.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcColumnType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumnType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcComplexProperty_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert (sizeof([temp for temp in hasproperties if self == temp])) == 0 + + + + +class IfcComplexProperty_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + +class IfcComplexPropertyTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + +class IfcComplexPropertyTemplate_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert (sizeof([temp for temp in haspropertytemplates if self == temp])) == 0 + + + + + +class IfcCompositeCurve_CurveContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "CurveContinuous" + + @staticmethod + def __call__(self): + segments = self.Segments + closedcurve = self.ClosedCurve + + assert ((not closedcurve) and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 1)) or (closedcurve and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 0)) + + + + +class IfcCompositeCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (sizeof([temp for temp in segments if temp.Dim != (segments[1 - 1].Dim)])) == 0 + + + + +def calc_IfcCompositeCurve_NSegments(self): + segments = self.Segments + return \ + sizeof(segments) + + + +def calc_IfcCompositeCurve_ClosedCurve(self): + segments = self.Segments + nsegments = self.NSegments + return \ + (segments[nsegments - 1].Transition) != discontinuous + + + + +class IfcCompositeCurveOnSurface_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveOnSurface" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + + assert sizeof(basissurface) > 0 + + + + +def calc_IfcCompositeCurveOnSurface_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + +class IfcCompositeCurveSegment_ParentIsBoundedCurve: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveSegment" + RULE_NAME = "ParentIsBoundedCurve" + + @staticmethod + def __call__(self): + parentcurve = self.ParentCurve + + assert 'ifc4x3_rc1.ifcboundedcurve' in typeof(parentcurve) + + + + +def calc_IfcCompositeCurveSegment_Dim(self): + parentcurve = self.ParentCurve + return \ + parentcurve.Dim + + + + +class IfcCompositeProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if temp.ProfileType != (profiles[1 - 1].ProfileType)])) == 0 + + + + +class IfcCompositeProfileDef_NoRecursion: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "NoRecursion" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if 'ifc4x3_rc1.ifccompositeprofiledef' in typeof(temp)])) == 0 + + + + + +class IfcCompressor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCompressor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccompressortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCompressorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCondenser_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCondenser_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccondensertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCondenserType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenserType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcConstraint_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcConstraint" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + constraintgrade = self.ConstraintGrade + + assert (constraintgrade != IfcConstraintEnum.USERDEFINED) or ((constraintgrade == IfcConstraintEnum.USERDEFINED) and exists(self.UserDefinedGrade)) + + + + + +class IfcConstructionEquipmentResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionEquipmentResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionMaterialResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionMaterialResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionProductResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionProductResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + + + + + + + + + + + + + +class IfcController_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcController_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccontrollertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcControllerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcControllerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcConveyorSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConveyorSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcConveyorSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcConveyorSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcconveyorsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcConveyorSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConveyorSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcConveyorSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCooledBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCooledBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccooledbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCooledBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCoolingTower_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoolingTower_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccoolingtowertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoolingTowerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTowerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + +class IfcCourse_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCourse" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCourseTypeEnum.USERDEFINED) or ((predefinedtype == IfcCourseTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCourse_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCourse" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccoursetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCourseType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCourseType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCourseTypeEnum.USERDEFINED) or ((predefinedtype == IfcCourseTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCovering_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCovering_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccoveringtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoveringType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoveringType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCrewResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcCrewResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +def calc_IfcCsgPrimitive3D_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcCurtainWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCurtainWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifccurtainwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCurtainWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcCurve_Dim(self): + + return \ + IfcCurveDim(self) + + + + + + + + + + + + + +class IfcCurveStyle_MeasureOfWidth: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "MeasureOfWidth" + + @staticmethod + def __call__(self): + curvewidth = self.CurveWidth + + assert (not exists(curvewidth)) or ('ifc4x3_rc1.ifcpositivelengthmeasure' in typeof(curvewidth)) or (('ifc4x3_rc1.ifcdescriptivemeasure' in typeof(curvewidth)) and (curvewidth == 'bylayer')) + + + + +class IfcCurveStyle_IdentifiableCurveStyle: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "IdentifiableCurveStyle" + + @staticmethod + def __call__(self): + curvefont = self.CurveFont + curvewidth = self.CurveWidth + curvecolour = self.CurveColour + + assert exists(curvefont) or exists(curvewidth) or exists(curvecolour) + + + + + + + + + + + +class IfcCurveStyleFontPattern_VisibleLengthGreaterEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyleFontPattern" + RULE_NAME = "VisibleLengthGreaterEqualZero" + + @staticmethod + def __call__(self): + visiblesegmentlength = self.VisibleSegmentLength + + assert visiblesegmentlength >= 0. + + + + + + + + +class IfcDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDeepFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDeepFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcdeepfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + + + + +class IfcDerivedProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + parentprofile = self.ParentProfile + + assert self.ProfileType == parentprofile.ProfileType + + + + + +class IfcDerivedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof(elements) > 1) or ((sizeof(elements) == 1) and ((elements[1 - 1].Exponent) != 1)) + + + + +class IfcDerivedUnit_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + unittype = self.UnitType + + assert (unittype != IfcDerivedUnitEnum.USERDEFINED) or ((unittype == IfcDerivedUnitEnum.USERDEFINED) and exists(self.UserDefinedType)) + + + + +def calc_IfcDerivedUnit_Dimensions(self): + elements = self.Elements + return \ + IfcDeriveDimensionalExponents(elements) + + + + + + + + + + +class IfcDirection_MagnitudeGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcDirection" + RULE_NAME = "MagnitudeGreaterZero" + + @staticmethod + def __call__(self): + directionratios = self.DirectionRatios + + assert (sizeof([tmp for tmp in directionratios if tmp != 0.0])) > 0 + + + + +def calc_IfcDirection_Dim(self): + directionratios = self.DirectionRatios + return \ + hiindex(directionratios) + + + + +class IfcDirectrixCurveSweptAreaSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcDirectrixCurveSweptAreaSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x3_rc1.ifcconic','ifc4x3_rc1.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + + + + +class IfcDiscreteAccessory_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDiscreteAccessory_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcdiscreteaccessorytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDiscreteAccessoryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessoryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDistributionChamberElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionChamberElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcdistributionchamberelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionChamberElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDocumentReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDocumentReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + name = self.Name + referenceddocument = self.ReferencedDocument + + assert exists(name) ^ exists(referenceddocument) + + + + + +class IfcDoor_CorrectStyleAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectStyleAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcdoortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDoorLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcDoorLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + thresholddepth = self.ThresholdDepth + thresholdthickness = self.ThresholdThickness + + assert not exists(thresholddepth) and (not exists(thresholdthickness)) + + + + +class IfcDoorLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + transomthickness = self.TransomThickness + transomoffset = self.TransomOffset + + assert (exists(transomoffset) and exists(transomthickness)) ^ ((not exists(transomoffset)) and (not exists(transomthickness))) + + + + +class IfcDoorLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + casingthickness = self.CasingThickness + casingdepth = self.CasingDepth + + assert (exists(casingdepth) and exists(casingthickness)) ^ ((not exists(casingdepth)) and (not exists(casingthickness))) + + + + +class IfcDoorLiningProperties_WR35: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR35" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc1.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc1.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcDoorPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc1.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc1.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + + + + + + + +class IfcDoorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDoorTypeEnum.USERDEFINED) or ((predefinedtype == IfcDoorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDraughtingPreDefinedColour_PreDefinedColourNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedColour" + RULE_NAME = "PreDefinedColourNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['black','red','green','blue','yellow','magenta','cyan','white','bylayer'] + + + + + +class IfcDraughtingPreDefinedCurveFont_PreDefinedCurveFontNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedCurveFont" + RULE_NAME = "PreDefinedCurveFontNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['continuous','chain','chaindoubledash','dashed','dotted','bylayer'] + + + + + +class IfcDuctFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcductfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcductsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSilencer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSilencer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcductsilencertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSilencerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEarthworksCut_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEarthworksCut" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEarthworksCutTypeEnum.USERDEFINED) or ((predefinedtype == IfcEarthworksCutTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcEarthworksFill_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEarthworksFill" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEarthworksFillTypeEnum.USERDEFINED) or ((predefinedtype == IfcEarthworksFillTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcEdgeLoop_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + edgelist = self.EdgeList + ne = self.Ne + + assert (edgelist[1 - 1].EdgeStart) == (edgelist[ne - 1].EdgeEnd) + + + + +class IfcEdgeLoop_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcLoopHeadToTail(self) + + + + +def calc_IfcEdgeLoop_Ne(self): + edgelist = self.EdgeList + return \ + sizeof(edgelist) + + + + +class IfcElectricAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcelectricappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcelectricdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowStorageDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowStorageDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcelectricflowstoragedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowStorageDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowTreatmentDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowTreatmentDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcelectricflowtreatmentdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowTreatmentDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricGenerator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricGenerator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcelectricgeneratortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricGeneratorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGeneratorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricMotor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricMotor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcelectricmotortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricMotorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricTimeControl_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricTimeControl_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcelectrictimecontroltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricTimeControlType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControlType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcElementAssembly_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElementAssembly_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcelementassemblytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElementAssemblyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssemblyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcElementQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcElementQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + quantities = self.Quantities + + assert IfcUniqueQuantityNames(quantities) + + + + + + + + + + + + + + + + + + + + + + + +class IfcEngine_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEngine_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcenginetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEngineType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngineType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporativeCooler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporativeCooler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcevaporativecoolertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporativeCoolerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCoolerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcevaporatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvent_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvent_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (not exists(eventtriggertype)) or (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + +class IfcEventType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + +class IfcEventType_CorrectEventTriggerType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectEventTriggerType" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + + + + +class IfcExternalReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcExternalReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + location = self.Location + identification = self.Identification + name = self.Name + + assert exists(identification) or exists(location) or exists(name) + + + + + + + + + + + + + + + + + + + + + + + +class IfcExtrudedAreaSolid_ValidExtrusionDirection: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolid" + RULE_NAME = "ValidExtrusionDirection" + + @staticmethod + def __call__(self): + + + assert IfcDotProduct(IfcDirection(DirectionRatios=[0.0,0.0,1.0]),self.ExtrudedDirection) != 0.0 + + + + + +class IfcExtrudedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + +class IfcFace_HasOuterBound: + SCOPE = "entity" + TYPE_NAME = "IfcFace" + RULE_NAME = "HasOuterBound" + + @staticmethod + def __call__(self): + bounds = self.Bounds + + assert (sizeof([temp for temp in bounds if 'ifc4x3_rc1.ifcfaceouterbound' in typeof(temp)])) <= 1 + + + + + +def calc_IfcFaceBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFan_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcfantype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFanType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFanType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcFeatureElementSubtraction_HasNoSubtraction: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "HasNoSubtraction" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasOpenings) == 0 + + + + +class IfcFeatureElementSubtraction_IsNotFilling: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "IsNotFilling" + + @staticmethod + def __call__(self): + + + assert sizeof(self.FillsVoids) == 0 + + + + + +class IfcFillAreaStyle_MaxOneColour: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneColour" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x3_rc1.ifccolour' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_MaxOneExtHatchStyle: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneExtHatchStyle" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x3_rc1.ifcexternallydefinedhatchstyle' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_ConsistentHatchStyleDef: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "ConsistentHatchStyleDef" + + @staticmethod + def __call__(self): + + + assert IfcCorrectFillAreaStyle(self.FillStyles) + + + + + +class IfcFillAreaStyleHatching_PatternStart2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "PatternStart2D" + + @staticmethod + def __call__(self): + patternstart = self.PatternStart + + assert (not exists(patternstart)) or (patternstart.Dim == 2) + + + + +class IfcFillAreaStyleHatching_RefHatchLine2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "RefHatchLine2D" + + @staticmethod + def __call__(self): + pointofreferencehatchline = self.PointOfReferenceHatchLine + + assert (not exists(pointofreferencehatchline)) or (pointofreferencehatchline.Dim == 2) + + + + + + + + +class IfcFilter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFilter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcfiltertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFilterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFireSuppressionTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFireSuppressionTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcfiresuppressionterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFireSuppressionTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + +class IfcFlowInstrument_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowInstrument_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcflowinstrumenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowInstrumentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrumentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFlowMeter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowMeter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcflowmetertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowMeterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFooting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFooting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcfootingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFootingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFootingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcFurniture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFurniture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcfurnituretype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFurnitureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurnitureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeographicElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcGeographicElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcgeographicelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcGeographicElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeometricCurveSet_NoSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricCurveSet" + RULE_NAME = "NoSurfaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Elements if 'ifc4x3_rc1.ifcsurface' in typeof(temp)])) == 0 + + + + + +class IfcGeometricRepresentationContext_North2D: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationContext" + RULE_NAME = "North2D" + + @staticmethod + def __call__(self): + truenorth = self.TrueNorth + + assert (not exists(truenorth)) or (hiindex(truenorth.DirectionRatios) == 2) + + + + + + + + +class IfcGeometricRepresentationSubContext_ParentNoSub: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "ParentNoSub" + + @staticmethod + def __call__(self): + parentcontext = self.ParentContext + + assert not 'ifc4x3_rc1.ifcgeometricrepresentationsubcontext' in typeof(parentcontext) + + + + +class IfcGeometricRepresentationSubContext_UserTargetProvided: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "UserTargetProvided" + + @staticmethod + def __call__(self): + targetview = self.TargetView + userdefinedtargetview = self.UserDefinedTargetView + + assert (targetview != IfcGeometricProjectionEnum.USERDEFINED) or ((targetview == IfcGeometricProjectionEnum.USERDEFINED) and exists(userdefinedtargetview)) + + + + +class IfcGeometricRepresentationSubContext_NoCoordOperation: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "NoCoordOperation" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasCoordinateOperation) == 0 + + + + +def calc_IfcGeometricRepresentationSubContext_WorldCoordinateSystem(self): + parentcontext = self.ParentContext + return \ + parentcontext.WorldCoordinateSystem + + + +def calc_IfcGeometricRepresentationSubContext_CoordinateSpaceDimension(self): + parentcontext = self.ParentContext + return \ + parentcontext.CoordinateSpaceDimension + + + +def calc_IfcGeometricRepresentationSubContext_TrueNorth(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.TrueNorth,IfcConvertDirectionInto2D(self.WorldCoordinateSystem.P[2 - 1])) + + + +def calc_IfcGeometricRepresentationSubContext_Precision(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.Precision,1) + + + + +class IfcGeometricSet_ConsistentDim: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricSet" + RULE_NAME = "ConsistentDim" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof([temp for temp in elements if temp.Dim != (elements[1 - 1].Dim)])) == 0 + + + + +def calc_IfcGeometricSet_Dim(self): + elements = self.Elements + return \ + elements[1 - 1].Dim + + + + + + + + + + + + + + + + + + + + + + +class IfcGridAxis_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + axiscurve = self.AxisCurve + + assert axiscurve.Dim == 2 + + + + +class IfcGridAxis_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + partofw = self.PartOfW + partofv = self.PartOfV + partofu = self.PartOfU + + assert (sizeof(partofu) == 1) ^ (sizeof(partofv) == 1) ^ (sizeof(partofw) == 1) + + + + + + + + + + + +def calc_IfcHalfSpaceSolid_Dim(self): + + return \ + 3 + + + + +class IfcHeatExchanger_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHeatExchanger_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcheatexchangertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHeatExchangerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchangerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcHumidifier_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHumidifier_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifchumidifiertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHumidifierType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifierType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + flangethickness = self.FlangeThickness + + assert (2. * flangethickness) < overalldepth + + + + +class IfcIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + webthickness = self.WebThickness + + assert webthickness < overallwidth + + + + +class IfcIShapeProfileDef_ValidFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFilletRadius" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + overalldepth = self.OverallDepth + webthickness = self.WebThickness + flangethickness = self.FlangeThickness + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or ((filletradius <= ((overallwidth - webthickness) / 2.)) and (filletradius <= ((overalldepth - (2. * flangethickness)) / 2.))) + + + + + + + + +class IfcImpactProtectionDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcImpactProtectionDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcImpactProtectionDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcimpactprotectiondevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcImpactProtectionDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcImpactProtectionDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcIndexedPolyCurve_Consecutive: + SCOPE = "entity" + TYPE_NAME = "IfcIndexedPolyCurve" + RULE_NAME = "Consecutive" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (not exists(segments)) or IfcConsecutiveSegments(segments) + + + + + + + + + + + + + + + + + +class IfcInterceptor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcInterceptor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcinterceptortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcInterceptorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIntersectionCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + +class IfcIntersectionCurve_DistinctSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "DistinctSurfaces" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) != (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + + + + + + + + + + + +class IfcJunctionBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcJunctionBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcjunctionboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcJunctionBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcLShapeProfileDef_ValidThickness: + SCOPE = "entity" + TYPE_NAME = "IfcLShapeProfileDef" + RULE_NAME = "ValidThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + thickness = self.Thickness + + assert (thickness < depth) and ((not exists(width)) or (thickness < width)) + + + + + +class IfcLaborResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcLaborResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +class IfcLamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifclamptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcLightFixture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLightFixture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifclightfixturetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLightFixtureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixtureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcLine_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcLine" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + pnt = self.Pnt + dir = self.Dir + + assert dir.Dim == pnt.Dim + + + + + + + + + + + + + + + + + + + + + + + +class IfcLiquidTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLiquidTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcLiquidTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLiquidTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcliquidterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLiquidTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLiquidTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcLiquidTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcLocalPlacement_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcLocalPlacement" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + placementrelto = self.PlacementRelTo + relativeplacement = self.RelativePlacement + + assert IfcCorrectLocalPlacement(relativeplacement,placementrelto) + + + + + + + + + + + + + + + + + +class IfcMarineFacility_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMarineFacility" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMarineFacilityTypeEnum.USERDEFINED) or ((predefinedtype == IfcMarineFacilityTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + + + + + + + + + + +class IfcMaterialDefinitionRepresentation_OnlyStyledRepresentations: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialDefinitionRepresentation" + RULE_NAME = "OnlyStyledRepresentations" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x3_rc1.ifcstyledrepresentation' in typeof(temp)])) == 0 + + + + + +class IfcMaterialLayer_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialLayer" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + +def calc_IfcMaterialLayerSet_TotalThickness(self): + + return \ + IfcMlsTotalThickness(self) + + + + + + + + + + + + + +class IfcMaterialProfile_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialProfile" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMechanicalFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMechanicalFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcmechanicalfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMechanicalFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMedicalDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMedicalDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcmedicaldevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMedicalDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMember_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMember_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcmembertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMemberStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcMemberStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc1.ifcrelassociates.relatedobjects') if ('ifc4x3_rc1.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc1.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcMemberType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMemberType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcMirroredProfileDef_Operator(self): + + return \ + IfcCartesianTransformationOperator2D(Axis1=IfcDirection(DirectionRatios=[-1.,0.]), Axis2=IfcDirection(DirectionRatios=[0.,1.]), LocalOrigin=IfcCartesianPoint(Coordinates=[0.,0.]), Scale=1.) + + + + +class IfcMobileTelecommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMobileTelecommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcmobiletelecommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMobileTelecommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcMooringDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMooringDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMooringDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMooringDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcmooringdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMooringDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMooringDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMooringDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMotorConnection_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMotorConnection_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcmotorconnectiontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMotorConnectionType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnectionType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcNamedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcNamedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert IfcCorrectDimensions(self.UnitType,self.Dimensions) + + + + + +class IfcNavigationElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcNavigationElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcNavigationElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcNavigationElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcnavigationelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcNavigationElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcNavigationElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcNavigationElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + isdefinedby = self.IsDefinedBy + + assert (sizeof(isdefinedby) == 0) or IfcUniqueDefinitionNames(isdefinedby) + + + + + + + + + + + +class IfcObjective_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcObjective" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + objectivequalifier = self.ObjectiveQualifier + + assert (objectivequalifier != IfcObjectiveEnum.USERDEFINED) or ((objectivequalifier == IfcObjectiveEnum.USERDEFINED) and exists(self.UserDefinedQualifier)) + + + + + +class IfcOccupant_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcOccupant" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not predefinedtype == IfcOccupantTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcOffsetCurve2D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve2D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 2 + + + + + +class IfcOffsetCurve3D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve3D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 3 + + + + + + + + +class IfcOpenCrossProfileDef_CorrectProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrectProfileType" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == IfcProfileTypeEnum.CURVE + + + + +class IfcOpenCrossProfileDef_CorrespondingSlopeWidths: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrespondingSlopeWidths" + + @staticmethod + def __call__(self): + widths = self.Widths + slopes = self.Slopes + + assert sizeof(slopes) == sizeof(widths) + + + + +class IfcOpenCrossProfileDef_CorrespondingTags: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrespondingTags" + + @staticmethod + def __call__(self): + slopes = self.Slopes + tags = self.Tags + + assert (not exists(tags)) or (sizeof(tags) == (sizeof(slopes) + 1)) + + + + + + + + + + + + + + + + + + + + + + + +class IfcOrientedEdge_EdgeElementNotOriented: + SCOPE = "entity" + TYPE_NAME = "IfcOrientedEdge" + RULE_NAME = "EdgeElementNotOriented" + + @staticmethod + def __call__(self): + edgeelement = self.EdgeElement + + assert not 'ifc4x3_rc1.ifcorientededge' in typeof(edgeelement) + + + + +def calc_IfcOrientedEdge_EdgeStart(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeStart,edgeelement.EdgeEnd) + + + +def calc_IfcOrientedEdge_EdgeEnd(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeEnd,edgeelement.EdgeStart) + + + + + + + +class IfcOutlet_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcOutlet_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcoutlettype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcOutletType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutletType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcOwnerHistory_CorrectChangeAction: + SCOPE = "entity" + TYPE_NAME = "IfcOwnerHistory" + RULE_NAME = "CorrectChangeAction" + + @staticmethod + def __call__(self): + changeaction = self.ChangeAction + lastmodifieddate = self.LastModifiedDate + + assert exists(lastmodifieddate) or ((not exists(lastmodifieddate)) and (not exists(changeaction))) or ((not exists(lastmodifieddate)) and exists(changeaction) and ((changeaction == IfcChangeActionEnum.NOTDEFINED) or (changeaction == IfcChangeActionEnum.NOCHANGE))) + + + + + + + + +class IfcPath_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcPath" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcPathHeadToTail(self) + + + + + + + + + + + +class IfcPcurve_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcPcurve" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + referencecurve = self.ReferenceCurve + + assert referencecurve.Dim == 2 + + + + + + + + + + + + + + +class IfcPerson_IdentifiablePerson: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "IdentifiablePerson" + + @staticmethod + def __call__(self): + identification = self.Identification + familyname = self.FamilyName + givenname = self.GivenName + + assert exists(identification) or exists(familyname) or exists(givenname) + + + + +class IfcPerson_ValidSetOfNames: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "ValidSetOfNames" + + @staticmethod + def __call__(self): + familyname = self.FamilyName + givenname = self.GivenName + middlenames = self.MiddleNames + + assert (not exists(middlenames)) or exists(familyname) or exists(givenname) + + + + + + + + +class IfcPhysicalComplexQuantity_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert (sizeof([temp for temp in hasquantities if self == temp])) == 0 + + + + +class IfcPhysicalComplexQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert IfcUniqueQuantityNames(hasquantities) + + + + + + + + + + + +class IfcPile_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPile_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcpiletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPileType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPileType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcpipefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcpipesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPixelTexture_MinPixelInS: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInS" + + @staticmethod + def __call__(self): + width = self.Width + + assert width >= 1 + + + + +class IfcPixelTexture_MinPixelInT: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInT" + + @staticmethod + def __call__(self): + height = self.Height + + assert height >= 1 + + + + +class IfcPixelTexture_NumberOfColours: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "NumberOfColours" + + @staticmethod + def __call__(self): + colourcomponents = self.ColourComponents + + assert 1 <= colourcomponents <= 4 + + + + +class IfcPixelTexture_SizeOfPixelList: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "SizeOfPixelList" + + @staticmethod + def __call__(self): + width = self.Width + height = self.Height + pixel = self.Pixel + + assert sizeof(pixel) == (width * height) + + + + +class IfcPixelTexture_PixelAsByteAndSameLength: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "PixelAsByteAndSameLength" + + @staticmethod + def __call__(self): + pixel = self.Pixel + + assert (sizeof([temp for temp in pixel if ((blength(temp) % 8) == 0) and (blength(temp) == (blength(pixel[1 - 1])))])) == sizeof(pixel) + + + + + +def calc_IfcPlacement_Dim(self): + location = self.Location + return \ + location.Dim + + + + + + + + + + + + + + + + +class IfcPlate_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPlate_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcplatetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPlateStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcPlateStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc1.ifcrelassociates.relatedobjects') if ('ifc4x3_rc1.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc1.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcPlateType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlateType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcPointOnCurve_Dim(self): + basiscurve = self.BasisCurve + return \ + basiscurve.Dim + + + + +def calc_IfcPointOnSurface_Dim(self): + basissurface = self.BasisSurface + return \ + basissurface.Dim + + + + +class IfcPolyLoop_AllPointsSameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyLoop" + RULE_NAME = "AllPointsSameDim" + + @staticmethod + def __call__(self): + polygon = self.Polygon + + assert (sizeof([temp for temp in polygon if temp.Dim != (polygon[1 - 1].Dim)])) == 0 + + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryDim" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert polygonalboundary.Dim == 2 + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryType: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryType" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert (sizeof(typeof(polygonalboundary) * ['ifc4x3_rc1.ifcpolyline','ifc4x3_rc1.ifccompositecurve'])) == 1 + + + + + + + + +class IfcPolyline_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyline" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + points = self.Points + + assert (sizeof([temp for temp in points if temp.Dim != (points[1 - 1].Dim)])) == 0 + + + + + + + + +class IfcPositioningElement_HasPlacement: + SCOPE = "entity" + TYPE_NAME = "IfcPositioningElement" + RULE_NAME = "HasPlacement" + + @staticmethod + def __call__(self): + + + assert exists(self.ObjectPlacement) + + + + + +class IfcPostalAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPostalAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + internallocation = self.InternalLocation + addresslines = self.AddressLines + postalbox = self.PostalBox + town = self.Town + region = self.Region + postalcode = self.PostalCode + country = self.Country + + assert exists(internallocation) or exists(addresslines) or exists(postalbox) or exists(postalcode) or exists(town) or exists(region) or exists(country) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPresentationLayerAssignment_ApplicableItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerAssignment" + RULE_NAME = "ApplicableItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x3_rc1.ifcshaperepresentation','ifc4x3_rc1.ifcgeometricrepresentationitem','ifc4x3_rc1.ifcmappeditem'])) == 1])) == sizeof(assigneditems) + + + + + +class IfcPresentationLayerWithStyle_ApplicableOnlyToItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerWithStyle" + RULE_NAME = "ApplicableOnlyToItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x3_rc1.ifcgeometricrepresentationitem','ifc4x3_rc1.ifcmappeditem'])) >= 1])) == sizeof(assigneditems) + + + + + + + + + + + +class IfcProcedure_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProcedure_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcProcedureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + + + + +class IfcProduct_PlacementForShapeRepresentation: + SCOPE = "entity" + TYPE_NAME = "IfcProduct" + RULE_NAME = "PlacementForShapeRepresentation" + + @staticmethod + def __call__(self): + objectplacement = self.ObjectPlacement + representation = self.Representation + + assert (exists(representation) and exists(objectplacement)) or (exists(representation) and ((sizeof([temp for temp in representation.Representations if 'ifc4x3_rc1.ifcshaperepresentation' in typeof(temp)])) == 0)) or (not exists(representation)) + + + + + +class IfcProductDefinitionShape_OnlyShapeModel: + SCOPE = "entity" + TYPE_NAME = "IfcProductDefinitionShape" + RULE_NAME = "OnlyShapeModel" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x3_rc1.ifcshapemodel' in typeof(temp)])) == 0 + + + + + + + + + + + + + + +class IfcProject_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProject_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert (not exists(self.RepresentationContexts)) or ((sizeof([temp for temp in self.RepresentationContexts if 'ifc4x3_rc1.ifcgeometricrepresentationsubcontext' in typeof(temp)])) == 0) + + + + +class IfcProject_NoDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "NoDecomposition" + + @staticmethod + def __call__(self): + + + assert sizeof(self.Decomposes) == 0 + + + + + + + + + + + +class IfcProjectedCRS_IsLengthUnit: + SCOPE = "entity" + TYPE_NAME = "IfcProjectedCRS" + RULE_NAME = "IsLengthUnit" + + @staticmethod + def __call__(self): + mapunit = self.MapUnit + + assert (not exists(mapunit)) or (mapunit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + + + + + + + + + + + +class IfcPropertyBoundedValue_SameUnitUpperLower: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperLower" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + lowerboundvalue = self.LowerBoundValue + + assert (not exists(upperboundvalue)) or (not exists(lowerboundvalue)) or (typeof(upperboundvalue) == typeof(lowerboundvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitUpperSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperSet" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(upperboundvalue)) or (not exists(setpointvalue)) or (typeof(upperboundvalue) == typeof(setpointvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitLowerSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitLowerSet" + + @staticmethod + def __call__(self): + lowerboundvalue = self.LowerBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(lowerboundvalue)) or (not exists(setpointvalue)) or (typeof(lowerboundvalue) == typeof(setpointvalue)) + + + + + + + + +class IfcPropertyDependencyRelationship_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyDependencyRelationship" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + dependingproperty = self.DependingProperty + dependantproperty = self.DependantProperty + + assert dependingproperty != dependantproperty + + + + + +class IfcPropertyEnumeratedValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeratedValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + enumerationvalues = self.EnumerationValues + enumerationreference = self.EnumerationReference + + assert (not exists(enumerationreference)) or (not exists(enumerationvalues)) or ((sizeof([temp for temp in enumerationvalues if temp in enumerationreference.EnumerationValues])) == sizeof(enumerationvalues)) + + + + + +class IfcPropertyEnumeration_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeration" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.EnumerationValues if not (typeof(self.EnumerationValues[1 - 1])) == typeof(temp)])) == 0 + + + + + +class IfcPropertyListValue_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyListValue" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.ListValues if not (typeof(self.ListValues[1 - 1])) == typeof(temp)])) == 0 + + + + + + + + +class IfcPropertySet_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySet_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + + + + +class IfcPropertySetTemplate_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySetTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + + + + + +class IfcPropertyTableValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + definedvalues = self.DefinedValues + + assert ((not exists(definingvalues)) and (not exists(definedvalues))) or (sizeof(definingvalues) == sizeof(definedvalues)) + + + + +class IfcPropertyTableValue_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + + assert (not exists(definingvalues)) or ((sizeof([temp for temp in self.DefiningValues if typeof(temp) != (typeof(self.DefiningValues[1 - 1]))])) == 0) + + + + +class IfcPropertyTableValue_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + definedvalues = self.DefinedValues + + assert (not exists(definedvalues)) or ((sizeof([temp for temp in self.DefinedValues if typeof(temp) != (typeof(self.DefinedValues[1 - 1]))])) == 0) + + + + + + + + + + + +class IfcProtectiveDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcprotectivedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcprotectivedevicetrippingunittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProtectiveDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProxy_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcProxy" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcPump_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPump_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcpumptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPumpType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPumpType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcQuantityArea_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.AREAUNIT) + + + + +class IfcQuantityArea_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + areavalue = self.AreaValue + + assert areavalue >= 0. + + + + + +class IfcQuantityCount_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityCount" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + countvalue = self.CountValue + + assert countvalue >= 0. + + + + + +class IfcQuantityLength_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + +class IfcQuantityLength_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + lengthvalue = self.LengthValue + + assert lengthvalue >= 0. + + + + + + + + +class IfcQuantityTime_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.TIMEUNIT) + + + + +class IfcQuantityTime_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + timevalue = self.TimeValue + + assert timevalue >= 0. + + + + + +class IfcQuantityVolume_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.VOLUMEUNIT) + + + + +class IfcQuantityVolume_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + volumevalue = self.VolumeValue + + assert volumevalue >= 0. + + + + + +class IfcQuantityWeight_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.MASSUNIT) + + + + +class IfcQuantityWeight_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + weightvalue = self.WeightValue + + assert weightvalue >= 0. + + + + + +class IfcRail_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRail" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRail_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRail" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcrailtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRailing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRailing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcrailingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcRamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcramptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRampFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcrampflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRationalBSplineCurveWithKnots_SameNumOfWeightsAndPoints: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "SameNumOfWeightsAndPoints" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert sizeof(weightsdata) == sizeof(self.ControlPointsList) + + + + +class IfcRationalBSplineCurveWithKnots_WeightsGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "WeightsGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcCurveWeightsPositive(self) + + + + +def calc_IfcRationalBSplineCurveWithKnots_Weights(self): + weightsdata = self.WeightsData + return \ + IfcListToArray(weightsdata,0,self.UpperIndexOnControlPoints) + + + + +class IfcRationalBSplineSurfaceWithKnots_CorrespondingWeightsDataLists: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingWeightsDataLists" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert (sizeof(weightsdata) == sizeof(self.ControlPointsList)) and ((sizeof(weightsdata[1 - 1])) == (sizeof(self.ControlPointsList[1 - 1]))) + + + + +class IfcRationalBSplineSurfaceWithKnots_WeightValuesGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "WeightValuesGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcSurfaceWeightsPositive(self) + + + + +def calc_IfcRationalBSplineSurfaceWithKnots_Weights(self): + uupper = self.UUpper + vupper = self.VUpper + weightsdata = self.WeightsData + return \ + IfcMakeArrayOfArray(weightsdata,0,uupper,0,vupper) + + + + +class IfcRectangleHollowProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert (wallthickness < (self.XDim / 2.)) and (wallthickness < (self.YDim / 2.)) + + + + +class IfcRectangleHollowProfileDef_ValidInnerRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidInnerRadius" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + innerfilletradius = self.InnerFilletRadius + + assert (not exists(innerfilletradius)) or ((innerfilletradius <= ((self.XDim / 2.) - wallthickness)) and (innerfilletradius <= ((self.YDim / 2.) - wallthickness))) + + + + +class IfcRectangleHollowProfileDef_ValidOuterRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidOuterRadius" + + @staticmethod + def __call__(self): + outerfilletradius = self.OuterFilletRadius + + assert (not exists(outerfilletradius)) or ((outerfilletradius <= (self.XDim / 2.)) and (outerfilletradius <= (self.YDim / 2.))) + + + + + + + + + + + +class IfcRectangularTrimmedSurface_U1AndU2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "U1AndU2Different" + + @staticmethod + def __call__(self): + u1 = self.U1 + u2 = self.U2 + + assert u1 != u2 + + + + +class IfcRectangularTrimmedSurface_V1AndV2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "V1AndV2Different" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + + assert v1 != v2 + + + + +class IfcRectangularTrimmedSurface_UsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "UsenseCompatible" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + u1 = self.U1 + u2 = self.U2 + usense = self.Usense + + assert (('ifc4x3_rc1.ifcelementarysurface' in typeof(basissurface)) and (not 'ifc4x3_rc1.ifcplane' in typeof(basissurface))) or ('ifc4x3_rc1.ifcsurfaceofrevolution' in typeof(basissurface)) or (usense == (u2 > u1)) + + + + +class IfcRectangularTrimmedSurface_VsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "VsenseCompatible" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + vsense = self.Vsense + + assert vsense == (v2 > v1) + + + + + + + + + + + + + + + + + +class IfcReinforcedSoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcedSoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcedSoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcedSoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcReinforcingBar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingBar_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcreinforcingbartype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingBarType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + +class IfcReinforcingBarType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + + + + + + + + +class IfcReinforcingMesh_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingMesh_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcreinforcingmeshtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingMeshType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + +class IfcReinforcingMeshType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + + +class IfcRelAggregates_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAggregates" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelAssigns_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssigns" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatedobjects = self.RelatedObjects + relatedobjectstype = self.RelatedObjectsType + + assert IfcCorrectObjectAssignment(relatedobjectstype,relatedobjects) + + + + + +class IfcRelAssignsToActor_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToActor" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingactor = self.RelatingActor + + assert (sizeof([temp for temp in self.RelatedObjects if relatingactor == temp])) == 0 + + + + + +class IfcRelAssignsToControl_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToControl" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontrol = self.RelatingControl + + assert (sizeof([temp for temp in self.RelatedObjects if relatingcontrol == temp])) == 0 + + + + + +class IfcRelAssignsToGroup_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToGroup" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatinggroup = self.RelatingGroup + + assert (sizeof([temp for temp in self.RelatedObjects if relatinggroup == temp])) == 0 + + + + + + + + +class IfcRelAssignsToProcess_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProcess" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + + assert (sizeof([temp for temp in self.RelatedObjects if relatingprocess == temp])) == 0 + + + + + +class IfcRelAssignsToProduct_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProduct" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingproduct = self.RelatingProduct + + assert (sizeof([temp for temp in self.RelatedObjects if relatingproduct == temp])) == 0 + + + + + +class IfcRelAssignsToResource_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToResource" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingresource = self.RelatingResource + + assert (sizeof([temp for temp in self.RelatedObjects if relatingresource == temp])) == 0 + + + + + + + + + + + + + + + + + + + + + + + +class IfcRelAssociatesMaterial_NoVoidElement: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "NoVoidElement" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if ('ifc4x3_rc1.ifcfeatureelementsubtraction' in typeof(temp)) or ('ifc4x3_rc1.ifcvirtualelement' in typeof(temp))])) == 0 + + + + +class IfcRelAssociatesMaterial_AllowedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "AllowedElements" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if (sizeof(typeof(temp) * ['ifc4x3_rc1.ifcelement','ifc4x3_rc1.ifcelementtype','ifc4x3_rc1.ifcwindowstyle','ifc4x3_rc1.ifcdoorstyle','ifc4x3_rc1.ifcstructuralmember','ifc4x3_rc1.ifcport'])) == 0])) == 0 + + + + + + + + + + + +class IfcRelConnectsElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelConnectsPathElements_NormalizedRelatingPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatingPriorities" + + @staticmethod + def __call__(self): + relatingpriorities = self.RelatingPriorities + + assert (sizeof(relatingpriorities) == 0) or ((sizeof([temp for temp in relatingpriorities if 0 <= temp <= 100])) == sizeof(relatingpriorities)) + + + + +class IfcRelConnectsPathElements_NormalizedRelatedPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatedPriorities" + + @staticmethod + def __call__(self): + relatedpriorities = self.RelatedPriorities + + assert (sizeof(relatedpriorities) == 0) or ((sizeof([temp for temp in relatedpriorities if 0 <= temp <= 100])) == sizeof(relatedpriorities)) + + + + + + + + +class IfcRelConnectsPorts_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPorts" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingport = self.RelatingPort + relatedport = self.RelatedPort + + assert relatingport != relatedport + + + + + + + + + + + + + + + + + +class IfcRelContainedInSpatialStructure_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRelContainedInSpatialStructure" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if 'ifc4x3_rc1.ifcspatialstructureelement' in typeof(temp)])) == 0 + + + + + + + + + + + +class IfcRelDeclares_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelDeclares" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontext = self.RelatingContext + relateddefinitions = self.RelatedDefinitions + + assert (sizeof([temp for temp in relateddefinitions if relatingcontext == temp])) == 0 + + + + + + + + + + + + + + +class IfcRelDefinesByProperties_NoRelatedTypeObject: + SCOPE = "entity" + TYPE_NAME = "IfcRelDefinesByProperties" + RULE_NAME = "NoRelatedTypeObject" + + @staticmethod + def __call__(self): + + + assert (sizeof([types for types in self.RelatedObjects if 'ifc4x3_rc1.ifctypeobject' in typeof(types)])) == 0 + + + + + + + + + + + + + + + + + +class IfcRelInterferesElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelInterferesElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelNests_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelNests" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelPositions_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelPositions" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingpositioningelement = self.RelatingPositioningElement + relatedproducts = self.RelatedProducts + + assert (sizeof([temp for temp in relatedproducts if relatingpositioningelement == temp])) == 0 + + + + + + + + +class IfcRelReferencedInSpatialStructure_AllowedRelatedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelReferencedInSpatialStructure" + RULE_NAME = "AllowedRelatedElements" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if ('ifc4x3_rc1.ifcspatialstructureelement' in typeof(temp)) and (not 'ifc4x3_rc1.ifcspace' in typeof(temp))])) == 0 + + + + + +class IfcRelSequence_AvoidInconsistentSequence: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "AvoidInconsistentSequence" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + relatedprocess = self.RelatedProcess + + assert relatingprocess != relatedprocess + + + + +class IfcRelSequence_CorrectSequenceType: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "CorrectSequenceType" + + @staticmethod + def __call__(self): + sequencetype = self.SequenceType + userdefinedsequencetype = self.UserDefinedSequenceType + + assert (sequencetype != IfcSequenceEnum.USERDEFINED) or ((sequencetype == IfcSequenceEnum.USERDEFINED) and exists(userdefinedsequencetype)) + + + + + + + + +class IfcRelSpaceBoundary_CorrectPhysOrVirt: + SCOPE = "entity" + TYPE_NAME = "IfcRelSpaceBoundary" + RULE_NAME = "CorrectPhysOrVirt" + + @staticmethod + def __call__(self): + relatedbuildingelement = self.RelatedBuildingElement + physicalorvirtualboundary = self.PhysicalOrVirtualBoundary + + assert ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Physical) and (not 'ifc4x3_rc1.ifcvirtualelement' in typeof(relatedbuildingelement))) or ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Virtual) and (('ifc4x3_rc1.ifcvirtualelement' in typeof(relatedbuildingelement)) or ('ifc4x3_rc1.ifcopeningelement' in typeof(relatedbuildingelement)))) or (physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.NotDefined) + + + + + + + + + + + + + + + + + +class IfcReparametrisedCompositeCurveSegment_PositiveLengthParameter: + SCOPE = "entity" + TYPE_NAME = "IfcReparametrisedCompositeCurveSegment" + RULE_NAME = "PositiveLengthParameter" + + @staticmethod + def __call__(self): + paramlength = self.ParamLength + + assert paramlength > 0.0 + + + + + + + + + + + + + + +class IfcRepresentationMap_ApplicableMappedRepr: + SCOPE = "entity" + TYPE_NAME = "IfcRepresentationMap" + RULE_NAME = "ApplicableMappedRepr" + + @staticmethod + def __call__(self): + mappedrepresentation = self.MappedRepresentation + + assert 'ifc4x3_rc1.ifcshapemodel' in typeof(mappedrepresentation) + + + + + + + + + + + + + + + + + + + + +class IfcRevolvedAreaSolid_AxisStartInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisStartInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Location.Coordinates[3 - 1]) == 0.0 + + + + +class IfcRevolvedAreaSolid_AxisDirectionInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisDirectionInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Z.DirectionRatios[3 - 1]) == 0.0 + + + + +def calc_IfcRevolvedAreaSolid_AxisLine(self): + axis = self.Axis + return \ + IfcLine(Pnt=axis.Location, Dir=IfcVector(Orientation=axis.Z, Magnitude=1.0)) + + + + +class IfcRevolvedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + + + + + + + + + + +class IfcRoof_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRoof_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcrooftype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRoofType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoofType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcRoundedRectangleProfileDef_ValidRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRoundedRectangleProfileDef" + RULE_NAME = "ValidRadius" + + @staticmethod + def __call__(self): + roundingradius = self.RoundingRadius + + assert (roundingradius <= (self.XDim / 2.)) and (roundingradius <= (self.YDim / 2.)) + + + + + +def calc_IfcSIUnit_Dimensions(self): + + return \ + IfcDimensionsForSiUnit(self.Name) + + + + +class IfcSanitaryTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSanitaryTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcsanitaryterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSanitaryTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSeamCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + +class IfcSeamCurve_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) == (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + + + + + + + + +class IfcSectionedSolid_DirectrixIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "DirectrixIs3D" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSectionedSolid_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSolid_SectionsSameType: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "SectionsSameType" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (typeof(crosssections[1 - 1])) != typeof(temp)])) == 0 + + + + + +class IfcSectionedSolidHorizontal_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSolidHorizontal_NoLongitudinalOffsets: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "NoLongitudinalOffsets" + + @staticmethod + def __call__(self): + crosssectionpositions = self.CrossSectionPositions + + assert (sizeof([temp for temp in crosssectionpositions if exists(temp.OffsetLongitudinal)])) == 0 + + + + + +class IfcSectionedSpine_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSpine_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSpine_SpineCurveDim: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "SpineCurveDim" + + @staticmethod + def __call__(self): + spinecurve = self.SpineCurve + + assert spinecurve.Dim == 3 + + + + +def calc_IfcSectionedSpine_Dim(self): + + return \ + 3 + + + + + + + +class IfcSensor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSensor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcsensortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSensorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcShadingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcShadingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcshadingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcShadingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcShapeModel_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcShapeModel" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + ofshapeaspect = self.OfShapeAspect + + assert (sizeof(self.OfProductRepresentation) == 1) ^ (sizeof(self.RepresentationMap) == 1) ^ (sizeof(ofshapeaspect) == 1) + + + + + +class IfcShapeRepresentation_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc1.ifcgeometricrepresentationcontext' in typeof(self.ContextOfItems) + + + + +class IfcShapeRepresentation_NoTopologicalItem: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "NoTopologicalItem" + + @staticmethod + def __call__(self): + items = self.Items + + assert (sizeof([temp for temp in items if ('ifc4x3_rc1.ifctopologicalrepresentationitem' in typeof(temp)) and (not (sizeof(['ifc4x3_rc1.ifcvertexpoint','ifc4x3_rc1.ifcedgecurve','ifc4x3_rc1.ifcfacesurface'] * typeof(temp))) == 1)])) == 0 + + + + +class IfcShapeRepresentation_HasRepresentationType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationType" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcShapeRepresentation_HasRepresentationIdentifier: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationIdentifier" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationIdentifier) + + + + +class IfcShapeRepresentation_CorrectItemsForType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectItemsForType" + + @staticmethod + def __call__(self): + + + assert IfcShapeRepresentationTypes(self.RepresentationType,self.Items) + + + + + +def calc_IfcShellBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + +class IfcSign_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSign" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSignTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSign_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSign" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcsigntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSignType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSignTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSignal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSignalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSignal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSignal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcsignaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSignalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSignalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcSlab_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSlab_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcslabtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSlabElementedCase_HasDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcSlabElementedCase" + RULE_NAME = "HasDecomposition" + + @staticmethod + def __call__(self): + + + assert hiindex(self.IsDecomposedBy) > 0 + + + + + +class IfcSlabStandardCase_HasMaterialLayerSetusage: + SCOPE = "entity" + TYPE_NAME = "IfcSlabStandardCase" + RULE_NAME = "HasMaterialLayerSetusage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc1.ifcrelassociates.relatedobjects') if ('ifc4x3_rc1.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc1.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcSlabType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlabType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSolarDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSolarDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcsolardevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSolarDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcSolidModel_Dim(self): + + return \ + 3 + + + + + + + +class IfcSpace_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpace_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcspacetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeater_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpaceHeater_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcspaceheatertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeaterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeaterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSpaceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcSpatialStructureElement_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialStructureElement" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + + + assert (hiindex(self.Decomposes) == 1) and ('ifc4x3_rc1.ifcrelaggregates' in (typeof(self.Decomposes[1 - 1]))) and (('ifc4x3_rc1.ifcproject' in (typeof(self.Decomposes[1 - 1].RelatingObject))) or ('ifc4x3_rc1.ifcspatialstructureelement' in (typeof(self.Decomposes[1 - 1].RelatingObject)))) + + + + + + + + +class IfcSpatialZone_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpatialZone_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcspatialzonetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpatialZoneType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZoneType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcStackTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStackTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcstackterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStackTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStair_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStair_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcstairtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStairFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcstairflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStairType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcStructuralAnalysisModel_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralAnalysisModel" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAnalysisModelTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + + + + +class IfcStructuralCurveAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralCurveAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveAction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert predefinedtype != IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + + + + + + + +class IfcStructuralCurveMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralCurveReaction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveReaction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.SINUS) and (predefinedtype != IfcStructuralCurveActivityTypeEnum.PARABOLA) + + + + + + + + +class IfcStructuralLinearAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc1.ifcstructuralloadlinearforce','ifc4x3_rc1.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + +class IfcStructuralLinearAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralCurveActivityTypeEnum.CONST + + + + + + + + +class IfcStructuralLoadCase_IsLoadCasePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadCase" + RULE_NAME = "IsLoadCasePredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcLoadGroupTypeEnum.LOAD_CASE + + + + + +class IfcStructuralLoadConfiguration_ValidListSize: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadConfiguration" + RULE_NAME = "ValidListSize" + + @staticmethod + def __call__(self): + values = self.Values + locations = self.Locations + + assert (not exists(locations)) or (sizeof(locations) == sizeof(values)) + + + + + +class IfcStructuralLoadGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + actiontype = self.ActionType + actionsource = self.ActionSource + + assert ((predefinedtype != IfcLoadGroupTypeEnum.USERDEFINED) and (actiontype != IfcActionTypeEnum.USERDEFINED) and (actionsource != IfcActionSourceTypeEnum.USERDEFINED)) or exists(self.ObjectType) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcStructuralPlanarAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc1.ifcstructuralloadplanarforce','ifc4x3_rc1.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + +class IfcStructuralPlanarAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralSurfaceActivityTypeEnum.CONST + + + + + +class IfcStructuralPointAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc1.ifcstructuralloadsingleforce','ifc4x3_rc1.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralPointReaction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointReaction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc1.ifcstructuralloadsingleforce','ifc4x3_rc1.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralResultGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralResultGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + theorytype = self.TheoryType + + assert (theorytype != IfcAnalysisTheoryTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcStructuralSurfaceAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralSurfaceAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceReaction_HasPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceReaction" + RULE_NAME = "HasPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStyledItem_ApplicableItem: + SCOPE = "entity" + TYPE_NAME = "IfcStyledItem" + RULE_NAME = "ApplicableItem" + + @staticmethod + def __call__(self): + item = self.Item + + assert not 'ifc4x3_rc1.ifcstyleditem' in typeof(item) + + + + + +class IfcStyledRepresentation_OnlyStyledItems: + SCOPE = "entity" + TYPE_NAME = "IfcStyledRepresentation" + RULE_NAME = "OnlyStyledItems" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x3_rc1.ifcstyleditem' in typeof(temp)])) == 0 + + + + + +class IfcSubContractResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcSubContractResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +def calc_IfcSurface_Dim(self): + + return \ + 3 + + + + +class IfcSurfaceCurve_CurveIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIs3D" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert curve3d.Dim == 3 + + + + +class IfcSurfaceCurve_CurveIsNotPcurve: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIsNotPcurve" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert not 'ifc4x3_rc1.ifcpcurve' in typeof(curve3d) + + + + +def calc_IfcSurfaceCurve_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + + + + +class IfcSurfaceFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSurfaceFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcSurfaceOfLinearExtrusion_DepthGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceOfLinearExtrusion" + RULE_NAME = "DepthGreaterZero" + + @staticmethod + def __call__(self): + depth = self.Depth + + assert depth > 0. + + + + +def calc_IfcSurfaceOfLinearExtrusion_ExtrusionAxis(self): + extrudeddirection = self.ExtrudedDirection + depth = self.Depth + return \ + IfcVector(Orientation=extrudeddirection, Magnitude=depth) + + + + +def calc_IfcSurfaceOfRevolution_AxisLine(self): + axisposition = self.AxisPosition + return \ + IfcLine(Pnt=axisposition.Location, Dir=IfcVector(Orientation=axisposition.Z, Magnitude=1.0)) + + + + +class IfcSurfaceReinforcementArea_SurfaceAndOrShearAreaSpecified: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "SurfaceAndOrShearAreaSpecified" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + surfacereinforcement2 = self.SurfaceReinforcement2 + shearreinforcement = self.ShearReinforcement + + assert exists(surfacereinforcement1) or exists(surfacereinforcement2) or exists(shearreinforcement) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea1: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea1" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + + assert (not exists(surfacereinforcement1)) or (((surfacereinforcement1[1 - 1]) >= 0.) and ((surfacereinforcement1[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement1) == 1) or ((surfacereinforcement1[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea2: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea2" + + @staticmethod + def __call__(self): + surfacereinforcement2 = self.SurfaceReinforcement2 + + assert (not exists(surfacereinforcement2)) or (((surfacereinforcement2[1 - 1]) >= 0.) and ((surfacereinforcement2[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement2) == 1) or ((surfacereinforcement2[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea3: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea3" + + @staticmethod + def __call__(self): + shearreinforcement = self.ShearReinforcement + + assert (not exists(shearreinforcement)) or (shearreinforcement >= 0.) + + + + + +class IfcSurfaceStyle_MaxOneShading: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneShading" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc1.ifcsurfacestyleshading' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneLighting: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneLighting" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc1.ifcsurfacestylelighting' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneRefraction: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneRefraction" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc1.ifcsurfacestylerefraction' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneTextures: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneTextures" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc1.ifcsurfacestylewithtextures' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneExtDefined: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneExtDefined" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc1.ifcexternallydefinedsurfacestyle' in typeof(style)])) <= 1 + + + + + + + + + + + + + + + + + + + + + + + +class IfcSweptAreaSolid_SweptAreaType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptAreaSolid" + RULE_NAME = "SweptAreaType" + + @staticmethod + def __call__(self): + sweptarea = self.SweptArea + + assert sweptarea.ProfileType == IfcProfileTypeEnum.Area + + + + + +class IfcSweptDiskSolid_DirectrixDim: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixDim" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSweptDiskSolid_InnerRadiusSize: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "InnerRadiusSize" + + @staticmethod + def __call__(self): + radius = self.Radius + innerradius = self.InnerRadius + + assert (not exists(innerradius)) or (radius > innerradius) + + + + +class IfcSweptDiskSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x3_rc1.ifcconic','ifc4x3_rc1.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + +class IfcSweptDiskSolidPolygonal_CorrectRadii: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "CorrectRadii" + + @staticmethod + def __call__(self): + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or (filletradius >= self.Radius) + + + + +class IfcSweptDiskSolidPolygonal_DirectrixIsPolyline: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "DirectrixIsPolyline" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_rc1.ifcpolyline' in typeof(self.Directrix)) or (('ifc4x3_rc1.ifcindexedpolycurve' in typeof(self.Directrix)) and (not exists(self.Directrix.Segments))) + + + + + +class IfcSweptSurface_SweptCurveType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptSurface" + RULE_NAME = "SweptCurveType" + + @staticmethod + def __call__(self): + sweptcurve = self.SweptCurve + + assert sweptcurve.ProfileType == IfcProfileTypeEnum.Curve + + + + + +class IfcSwitchingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSwitchingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcswitchingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSwitchingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSystemFurnitureElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSystemFurnitureElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcsystemfurnitureelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSystemFurnitureElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < depth + + + + +class IfcTShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcTable_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + rows = self.Rows + + assert (sizeof([temp for temp in rows if hiindex(temp.RowCells) != (hiindex(rows[1 - 1].RowCells))])) == 0 + + + + +class IfcTable_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + numberofheadings = self.NumberOfHeadings + + assert 0 <= numberofheadings <= 1 + + + + +def calc_IfcTable_NumberOfCellsInRow(self): + rows = self.Rows + return \ + hiindex(rows[1 - 1].RowCells) + + + +def calc_IfcTable_NumberOfHeadings(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if temp.IsHeading]) + + + +def calc_IfcTable_NumberOfDataRows(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if not temp.IsHeading]) + + + + + + + + + + +class IfcTank_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTank_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifctanktype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTankType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTankType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTask_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTask_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcTaskType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTaskType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + +class IfcTelecomAddress_MinimumDataProvided: + SCOPE = "entity" + TYPE_NAME = "IfcTelecomAddress" + RULE_NAME = "MinimumDataProvided" + + @staticmethod + def __call__(self): + telephonenumbers = self.TelephoneNumbers + facsimilenumbers = self.FacsimileNumbers + pagernumber = self.PagerNumber + electronicmailaddresses = self.ElectronicMailAddresses + wwwhomepageurl = self.WWWHomePageURL + messagingids = self.MessagingIDs + + assert exists(telephonenumbers) or exists(facsimilenumbers) or exists(pagernumber) or exists(electronicmailaddresses) or exists(wwwhomepageurl) or exists(messagingids) + + + + + +class IfcTendon_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendon_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifctendontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonAnchor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifctendonanchortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonConduit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonConduit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifctendonconduittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonConduitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcTessellatedFaceSet_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcTextLiteralWithExtent_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcTextLiteralWithExtent" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + extent = self.Extent + + assert not 'ifc4x3_rc1.ifcplanarbox' in typeof(extent) + + + + + + + + +class IfcTextStyleFontModel_MeasureOfFontSize: + SCOPE = "entity" + TYPE_NAME = "IfcTextStyleFontModel" + RULE_NAME = "MeasureOfFontSize" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_rc1.ifclengthmeasure' in typeof(self.FontSize)) and (self.FontSize > 0.) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTopologyRepresentation_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x3_rc1.ifctopologicalrepresentationitem' in typeof(temp)])) == 0 + + + + +class IfcTopologyRepresentation_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcTopologyRepresentation_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + + + assert IfcTopologyRepresentationTypes(self.RepresentationType,self.Items) + + + + + +class IfcToroidalSurface_MajorLargerMinor: + SCOPE = "entity" + TYPE_NAME = "IfcToroidalSurface" + RULE_NAME = "MajorLargerMinor" + + @staticmethod + def __call__(self): + majorradius = self.MajorRadius + minorradius = self.MinorRadius + + assert minorradius < majorradius + + + + + +class IfcTrackElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTrackElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTrackElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTrackElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifctrackelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTrackElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTrackElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTrackElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTransformer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransformer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifctranformertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransformerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcTransportElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or ((predefinedtype != IfcTransportElementFixedTypeEnum.USERDEFINED) and (predefinedtype != IfcTransportElementNonFixedTypeEnum.USERDEFINED)) or (((predefinedtype == IfcTransportElementFixedTypeEnum.USERDEFINED) or (predefinedtype == IfcTransportElementNonFixedTypeEnum.USERDEFINED)) and exists(self.ObjectType)) + + + + +class IfcTransportElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifctransportelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransportElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert ((predefinedtype != IfcTransportElementFixedTypeEnum.USERDEFINED) and (predefinedtype != IfcTransportElementNonFixedTypeEnum.USERDEFINED)) or (((predefinedtype == IfcTransportElementFixedTypeEnum.USERDEFINED) or (predefinedtype == IfcTransportElementNonFixedTypeEnum.USERDEFINED)) and exists(self.ElementType)) + + + + + + + + +def calc_IfcTriangulatedFaceSet_NumberOfTriangles(self): + coordindex = self.CoordIndex + return \ + sizeof(coordindex) + + + + +class IfcTriangulatedIrregularNetwork_NotClosed: + SCOPE = "entity" + TYPE_NAME = "IfcTriangulatedIrregularNetwork" + RULE_NAME = "NotClosed" + + @staticmethod + def __call__(self): + + + assert self.Closed == False + + + + + +class IfcTrimmedCurve_Trim1ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim1ValuesConsistent" + + @staticmethod + def __call__(self): + trim1 = self.Trim1 + + assert (hiindex(trim1) == 1) or ((typeof(trim1[1 - 1])) != (typeof(trim1[2 - 1]))) + + + + +class IfcTrimmedCurve_Trim2ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim2ValuesConsistent" + + @staticmethod + def __call__(self): + trim2 = self.Trim2 + + assert (hiindex(trim2) == 1) or ((typeof(trim2[1 - 1])) != (typeof(trim2[2 - 1]))) + + + + +class IfcTrimmedCurve_NoTrimOfBoundedCurves: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "NoTrimOfBoundedCurves" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert not 'ifc4x3_rc1.ifcboundedcurve' in typeof(basiscurve) + + + + + +class IfcTubeBundle_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTubeBundle_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifctubebundletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTubeBundleType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundleType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTypeObject_NameRequired: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "NameRequired" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTypeObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + haspropertysets = self.HasPropertySets + + assert (not exists(haspropertysets)) or IfcUniquePropertySetNames(haspropertysets) + + + + + + + + +class IfcTypeProduct_ApplicableOccurrence: + SCOPE = "entity" + TYPE_NAME = "IfcTypeProduct" + RULE_NAME = "ApplicableOccurrence" + + @staticmethod + def __call__(self): + + + assert (not exists(lambda: self.Types[1 - 1])) or ((sizeof([temp for temp in self.Types[1 - 1].RelatedObjects if not 'ifc4x3_rc1.ifcproduct' in typeof(temp)])) == 0) + + + + + + + + +class IfcUShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + +class IfcUShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcUnitAssignment_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcUnitAssignment" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + units = self.Units + + assert IfcCorrectUnitAssignment(units) + + + + + +class IfcUnitaryControlElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryControlElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcunitarycontrolelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryControlElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcUnitaryEquipment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryEquipment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcunitaryequipmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryEquipmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcValve_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcValve_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcvalvetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcValveType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValveType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVector_MagGreaterOrEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcVector" + RULE_NAME = "MagGreaterOrEqualZero" + + @staticmethod + def __call__(self): + magnitude = self.Magnitude + + assert magnitude >= 0.0 + + + + +def calc_IfcVector_Dim(self): + orientation = self.Orientation + return \ + orientation.Dim + + + + + + + + + + + + + +class IfcVibrationDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcvibrationdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVibrationIsolator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationIsolator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcvibrationisolatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationIsolatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcVoidingFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcVoidingFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVoidingFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWallElementedCase_HasDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcWallElementedCase" + RULE_NAME = "HasDecomposition" + + @staticmethod + def __call__(self): + + + assert hiindex(self.IsDecomposedBy) > 0 + + + + + +class IfcWallStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcWallStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc1.ifcrelassociates.relatedobjects') if ('ifc4x3_rc1.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc1.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWasteTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWasteTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcwasteterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWasteTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcWindow_CorrectStyleAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectStyleAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc1.ifcwindowtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWindowLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcWindowLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + firsttransomoffset = self.FirstTransomOffset + secondtransomoffset = self.SecondTransomOffset + + assert not (not exists(firsttransomoffset)) and exists(secondtransomoffset) + + + + +class IfcWindowLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + firstmullionoffset = self.FirstMullionOffset + secondmullionoffset = self.SecondMullionOffset + + assert not (not exists(firstmullionoffset)) and exists(secondmullionoffset) + + + + +class IfcWindowLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc1.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc1.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcWindowPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc1.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc1.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + + + + + + + +class IfcWindowType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWindowTypeEnum.USERDEFINED) or ((predefinedtype == IfcWindowTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWorkCalendar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkCalendar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkCalendarTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkCalendarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcWorkPlan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkPlan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkPlanTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkPlanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcWorkSchedule_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkSchedule" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkScheduleTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkScheduleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcZShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcZShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + + +class IfcZone_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcZone" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof(self.IsGroupedBy) == 0) or ((sizeof([temp for temp in self.IsGroupedBy[1 - 1].RelatedObjects if not ('ifc4x3_rc1.ifczone' in typeof(temp)) or ('ifc4x3_rc1.ifcspace' in typeof(temp)) or ('ifc4x3_rc1.ifcspatialzone' in typeof(temp))])) == 0) + + + + + +class IfcRepresentationContextSameWCS: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcGeometricRepresentationContext = file.by_type("IfcGeometricRepresentationContext") + isdifferent = False + if sizeof(IfcGeometricRepresentationContext) > 1: + for i in range(2, hiindex(IfcGeometricRepresentationContext) + 1): + if (IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem) != (IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem): + isdifferent = (not IfcSameValidPrecision(IfcGeometricRepresentationContext[1 - 1].Precision,IfcGeometricRepresentationContext[i - 1].Precision)) or (not IfcSameAxis2Placement(IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[1 - 1].Precision)) + if isdifferent == True: + break + + assert isdifferent == False + + + + + +class IfcSingleProjectInstance: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcProject = file.by_type("IfcProject") + + + + assert sizeof(IfcProject) <= 1 + + + + +def IfcAssociatedSurface(arg): + + surf = arg.BasisSurface + return surf + + +def IfcBaseAxis(dim, axis1, axis2, axis3): + + + + if dim == 3: + d1 = nvl(IfcNormalise(axis3),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,axis1) + u = [d2,IfcSecondProjAxis(d1,d2,axis2),d1] + else: + if exists(axis1): + d1 = IfcNormalise(axis1) + u = [d1,IfcOrthogonalComplement(d1)] + if exists(axis2): + factor = IfcDotProduct(axis2,u[2 - 1]) + if factor < 0.0: + u[2 - 1].DirectionRatios[1 - 1] = -u[2 - 1].DirectionRatios[1 - 1] + u[2 - 1].DirectionRatios[2 - 1] = -u[2 - 1].DirectionRatios[2 - 1] + else: + if exists(axis2): + d1 = IfcNormalise(axis2) + u = [IfcOrthogonalComplement(d1),d1] + u[1 - 1].DirectionRatios[1 - 1] = -u[1 - 1].DirectionRatios[1 - 1] + u[1 - 1].DirectionRatios[2 - 1] = -u[1 - 1].DirectionRatios[2 - 1] + else: + u = [IfcDirection(DirectionRatios=[1.0,0.0]),IfcDirection(DirectionRatios=[0.0,1.0])] + return u + + +def IfcBooleanChoose(b, choice1, choice2): + + if b: + return choice1 + else: + return choice2 + + +def IfcBuild2Axes(refdirection): + d = nvl(IfcNormalise(refdirection),IfcDirection(DirectionRatios=[1.0,0.0])) + return [d,IfcOrthogonalComplement(d)] + + +def IfcBuildAxes(axis, refdirection): + + d1 = nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,refdirection) + return [d2,IfcNormalise(IfcCrossProduct(d1,d2)).Orientation,d1] + + +def IfcConsecutiveSegments(segments): + result = True + for i in range(1, hiindex(segments) - 1 + 1): + if (segments[i - 1][hiindex(segments[i - 1]) - 1]) != (segments[i - 1][1 - 1]): + result = False + break + return result + + +def IfcConstraintsParamBSpline(degree, upknots, upcp, knotmult, knots): + result = True + + sum = knotmult[1 - 1] + for i in range(2, upknots + 1): + sum = sum + (knotmult[i - 1]) + if (degree < 1) or (upknots < 2) or (upcp < degree) or (sum != (degree + upcp + 2)): + result = False + return result + k = knotmult[1 - 1] + if (k < 1) or (k > (degree + 1)): + result = False + return result + for i in range(2, upknots + 1): + if ((knotmult[i - 1]) < 1) or ((knots[i - 1]) <= (knots[i - 1])): + result = False + return result + k = knotmult[i - 1] + if (i < upknots) and (k > degree): + result = False + return result + if (i == upknots) and (k > (degree + 1)): + result = False + return result + return result + + +def IfcConvertDirectionInto2D(direction): + direction2d = IfcDirection(DirectionRatios=[0.,1.]) + temp = list(direction2d.DirectionRatios) + temp[1 - 1] = direction.DirectionRatios[1 - 1] + direction2d.DirectionRatios = temp + temp = list(direction2d.DirectionRatios) + temp[2 - 1] = direction.DirectionRatios[2 - 1] + direction2d.DirectionRatios = temp + return direction2d + + +def IfcCorrectDimensions(m, dim): + + if m == lengthunit: + if dim == IfcDimensionalExponents(1,0,0,0,0,0,0): + return True + else: + return False + elif m == massunit: + if dim == IfcDimensionalExponents(0,1,0,0,0,0,0): + return True + else: + return False + elif m == timeunit: + if dim == IfcDimensionalExponents(0,0,1,0,0,0,0): + return True + else: + return False + elif m == electriccurrentunit: + if dim == IfcDimensionalExponents(0,0,0,1,0,0,0): + return True + else: + return False + elif m == thermodynamictemperatureunit: + if dim == IfcDimensionalExponents(0,0,0,0,1,0,0): + return True + else: + return False + elif m == amountofsubstanceunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,1,0): + return True + else: + return False + elif m == luminousintensityunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == planeangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == solidangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == areaunit: + if dim == IfcDimensionalExponents(2,0,0,0,0,0,0): + return True + else: + return False + elif m == volumeunit: + if dim == IfcDimensionalExponents(3,0,0,0,0,0,0): + return True + else: + return False + elif m == absorbeddoseunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == radioactivityunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == electriccapacitanceunit: + if dim == IfcDimensionalExponents(-2,-1,4,2,0,0,0): + return True + else: + return False + elif m == doseequivalentunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == electricchargeunit: + if dim == IfcDimensionalExponents(0,0,1,1,0,0,0): + return True + else: + return False + elif m == electricconductanceunit: + if dim == IfcDimensionalExponents(-2,-1,3,2,0,0,0): + return True + else: + return False + elif m == electricvoltageunit: + if dim == IfcDimensionalExponents(2,1,-3,-1,0,0,0): + return True + else: + return False + elif m == electricresistanceunit: + if dim == IfcDimensionalExponents(2,1,-3,-2,0,0,0): + return True + else: + return False + elif m == energyunit: + if dim == IfcDimensionalExponents(2,1,-2,0,0,0,0): + return True + else: + return False + elif m == forceunit: + if dim == IfcDimensionalExponents(1,1,-2,0,0,0,0): + return True + else: + return False + elif m == frequencyunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == inductanceunit: + if dim == IfcDimensionalExponents(2,1,-2,-2,0,0,0): + return True + else: + return False + elif m == illuminanceunit: + if dim == IfcDimensionalExponents(-2,0,0,0,0,0,1): + return True + else: + return False + elif m == luminousfluxunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == magneticfluxunit: + if dim == IfcDimensionalExponents(2,1,-2,-1,0,0,0): + return True + else: + return False + elif m == magneticfluxdensityunit: + if dim == IfcDimensionalExponents(0,1,-2,-1,0,0,0): + return True + else: + return False + elif m == powerunit: + if dim == IfcDimensionalExponents(2,1,-3,0,0,0,0): + return True + else: + return False + elif m == pressureunit: + if dim == IfcDimensionalExponents(-1,1,-2,0,0,0,0): + return True + else: + return False + else: + return unknown + + +def IfcCorrectFillAreaStyle(styles): + hatching = 0 + tiles = 0 + colour = 0 + external = 0 + external = sizeof([style for style in styles if 'ifc4x3_rc1.ifcexternallydefinedhatchstyle' in typeof(style)]) + hatching = sizeof([style for style in styles if 'ifc4x3_rc1.ifcfillareastylehatching' in typeof(style)]) + tiles = sizeof([style for style in styles if 'ifc4x3_rc1.ifcfillareastyletiles' in typeof(style)]) + colour = sizeof([style for style in styles if 'ifc4x3_rc1.ifccolour' in typeof(style)]) + if external > 1: + return False + if (external == 1) and ((hatching > 0) or (tiles > 0) or (colour > 0)): + return False + if colour > 1: + return False + if (hatching > 0) and (tiles > 0): + return False + return True + + +def IfcCorrectLocalPlacement(axisplacement, relplacement): + + if exists(relplacement): + if 'ifc4x3_rc1.ifcgridplacement' in typeof(relplacement): + return None + if 'ifc4x3_rc1.ifclocalplacement' in typeof(relplacement): + if 'ifc4x3_rc1.ifcaxis2placement2d' in typeof(axisplacement): + return True + if 'ifc4x3_rc1.ifcaxis2placement3d' in typeof(axisplacement): + if relplacement.RelativePlacement.Dim == 3: + return True + else: + return False + return True + return None + + +def IfcCorrectObjectAssignment(constraint, objects): + count = 0 + if not exists(constraint): + return True + if constraint == IfcObjectTypeEnum.NOTDEFINED: + return True + elif constraint == IfcObjectTypeEnum.PRODUCT: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc1.ifcproduct' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROCESS: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc1.ifcprocess' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.CONTROL: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc1.ifccontrol' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.RESOURCE: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc1.ifcresource' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.ACTOR: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc1.ifcactor' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.GROUP: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc1.ifcgroup' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROJECT: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc1.ifcproject' in typeof(temp)]) + return count == 0 + else: + return None + + +def IfcCorrectUnitAssignment(units): + namedunitnumber = 0 + derivedunitnumber = 0 + monetaryunitnumber = 0 + namedunitnames = express_set([]) + derivedunitnames = express_set([]) + namedunitnumber = sizeof([temp for temp in units if ('ifc4x3_rc1.ifcnamedunit' in typeof(temp)) and (not temp.UnitType == IfcUnitEnum.USERDEFINED)]) + derivedunitnumber = sizeof([temp for temp in units if ('ifc4x3_rc1.ifcderivedunit' in typeof(temp)) and (not temp.UnitType == IfcDerivedUnitEnum.USERDEFINED)]) + monetaryunitnumber = sizeof([temp for temp in units if 'ifc4x3_rc1.ifcmonetaryunit' in typeof(temp)]) + for i in range(1, sizeof(units) + 1): + if ('ifc4x3_rc1.ifcnamedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcUnitEnum.USERDEFINED): + namedunitnames = namedunitnames + (units[i - 1].UnitType) + if ('ifc4x3_rc1.ifcderivedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcDerivedUnitEnum.USERDEFINED): + derivedunitnames = derivedunitnames + (units[i - 1].UnitType) + return (sizeof(namedunitnames) == namedunitnumber) and (sizeof(derivedunitnames) == derivedunitnumber) and (monetaryunitnumber <= 1) + + +def IfcCrossProduct(arg1, arg2): + + + + + if ((not exists(arg1)) or (arg1.Dim == 2)) or ((not exists(arg2)) or (arg2.Dim == 2)): + return None + else: + v1 = IfcNormalise(arg1).DirectionRatios + v2 = IfcNormalise(arg2).DirectionRatios + res = IfcDirection(DirectionRatios=[((v1[2 - 1]) * (v2[3 - 1])) - ((v1[3 - 1]) * (v2[2 - 1])),((v1[3 - 1]) * (v2[1 - 1])) - ((v1[1 - 1]) * (v2[3 - 1])),((v1[1 - 1]) * (v2[2 - 1])) - ((v1[2 - 1]) * (v2[1 - 1]))]) + mag = 0.0 + for i in range(1, 3 + 1): + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=arg1, Magnitude=0.0) + return result + + +def IfcCurveDim(curve): + + if 'ifc4x3_rc1.ifcline' in typeof(curve): + return curve.Pnt.Dim + if 'ifc4x3_rc1.ifcconic' in typeof(curve): + return curve.Position.Dim + if 'ifc4x3_rc1.ifcpolyline' in typeof(curve): + return curve.Points[1 - 1].Dim + if 'ifc4x3_rc1.ifctrimmedcurve' in typeof(curve): + return IfcCurveDim(curve.BasisCurve) + if 'ifc4x3_rc1.ifccompositecurve' in typeof(curve): + return curve.Segments[1 - 1].Dim + if 'ifc4x3_rc1.ifcbsplinecurve' in typeof(curve): + return curve.ControlPointsList[1 - 1].Dim + if 'ifc4x3_rc1.ifcoffsetcurve2d' in typeof(curve): + return 2 + if 'ifc4x3_rc1.ifcoffsetcurve3d' in typeof(curve): + return 3 + if 'ifc4x3_rc1.ifcoffsetcurvebydistances' in typeof(curve): + return 3 + if 'ifc4x3_rc1.ifccurvesegment2d' in typeof(curve): + return 2 + if 'ifc4x3_rc1.ifcalignmentcurve' in typeof(curve): + return 3 + if 'ifc4x3_rc1.ifcpcurve' in typeof(curve): + return 3 + if 'ifc4x3_rc1.ifcindexedpolycurve' in typeof(curve): + return curve.Points.Dim + return None + + +def IfcCurveWeightsPositive(b): + result = True + for i in range(0, b.UpperIndexOnControlPoints + 1): + if (b.Weights[i - 1]) <= 0.0: + result = False + return result + return result + + +def IfcDeriveDimensionalExponents(unitelements): + result = IfcDimensionalExponents(0,0,0,0,0,0,0) + for i in range(loindex(unitelements), hiindex(unitelements) + 1): + result.LengthExponent = result.LengthExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LengthExponent)) + result.MassExponent = result.MassExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.MassExponent)) + result.TimeExponent = result.TimeExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.TimeExponent)) + result.ElectricCurrentExponent = result.ElectricCurrentExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ElectricCurrentExponent)) + result.ThermodynamicTemperatureExponent = result.ThermodynamicTemperatureExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ThermodynamicTemperatureExponent)) + result.AmountOfSubstanceExponent = result.AmountOfSubstanceExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.AmountOfSubstanceExponent)) + result.LuminousIntensityExponent = result.LuminousIntensityExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LuminousIntensityExponent)) + return result + + +def IfcDimensionsForSiUnit(n): + + if n == metre: + return IfcDimensionalExponents(1,0,0,0,0,0,0) + elif n == square_metre: + return IfcDimensionalExponents(2,0,0,0,0,0,0) + elif n == cubic_metre: + return IfcDimensionalExponents(3,0,0,0,0,0,0) + elif n == gram: + return IfcDimensionalExponents(0,1,0,0,0,0,0) + elif n == second: + return IfcDimensionalExponents(0,0,1,0,0,0,0) + elif n == ampere: + return IfcDimensionalExponents(0,0,0,1,0,0,0) + elif n == kelvin: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == mole: + return IfcDimensionalExponents(0,0,0,0,0,1,0) + elif n == candela: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == radian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == steradian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == hertz: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == newton: + return IfcDimensionalExponents(1,1,-2,0,0,0,0) + elif n == pascal: + return IfcDimensionalExponents(-1,1,-2,0,0,0,0) + elif n == joule: + return IfcDimensionalExponents(2,1,-2,0,0,0,0) + elif n == watt: + return IfcDimensionalExponents(2,1,-3,0,0,0,0) + elif n == coulomb: + return IfcDimensionalExponents(0,0,1,1,0,0,0) + elif n == volt: + return IfcDimensionalExponents(2,1,-3,-1,0,0,0) + elif n == farad: + return IfcDimensionalExponents(-2,-1,4,2,0,0,0) + elif n == ohm: + return IfcDimensionalExponents(2,1,-3,-2,0,0,0) + elif n == siemens: + return IfcDimensionalExponents(-2,-1,3,2,0,0,0) + elif n == weber: + return IfcDimensionalExponents(2,1,-2,-1,0,0,0) + elif n == tesla: + return IfcDimensionalExponents(0,1,-2,-1,0,0,0) + elif n == henry: + return IfcDimensionalExponents(2,1,-2,-2,0,0,0) + elif n == degree_celsius: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == lumen: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == lux: + return IfcDimensionalExponents(-2,0,0,0,0,0,1) + elif n == becquerel: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == gray: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + elif n == sievert: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + else: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + + +def IfcDotProduct(arg1, arg2): + + + + if (not exists(arg1)) or (not exists(arg2)): + scalar = None + else: + if arg1.Dim != arg2.Dim: + scalar = None + else: + vec1 = IfcNormalise(arg1) + vec2 = IfcNormalise(arg2) + ndim = arg1.Dim + scalar = 0.0 + for i in range(1, ndim + 1): + scalar = scalar + ((vec1.DirectionRatios[i - 1]) * (vec2.DirectionRatios[i - 1])) + return scalar + + +def IfcFirstProjAxis(zaxis, arg): + + + + + if not exists(zaxis): + return None + else: + z = IfcNormalise(zaxis) + if not exists(arg): + if z.DirectionRatios != [1.0,0.0,0.0]: + v = IfcDirection(DirectionRatios=[1.0,0.0,0.0]) + else: + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + if arg.Dim != 3: + return None + if IfcCrossProduct(arg,z).Magnitude == 0.0: + return None + else: + v = IfcNormalise(arg) + xvec = IfcScalarTimesVector(IfcDotProduct(v,z),z) + xaxis = IfcVectorDifference(v,xvec).Orientation + xaxis = IfcNormalise(xaxis) + return xaxis + + +def IfcGetBasisSurface(c): + + + surfs = [] + if 'ifc4x3_rc1.ifcpcurve' in typeof(c): + surfs = [c.BasisSurface] + else: + if 'ifc4x3_rc1.ifcsurfacecurve' in typeof(c): + n = sizeof(c.AssociatedGeometry) + for i in range(1, n + 1): + surfs = surfs + (IfcAssociatedSurface(c.AssociatedGeometry[i - 1])) + if 'ifc4x3_rc1.ifccompositecurveonsurface' in typeof(c): + n = sizeof(c.Segments) + surfs = IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve) + if n > 1: + for i in range(2, n + 1): + surfs = surfs * (IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve)) + return surfs + + +def IfcListToArray(lis, low, u): + + + n = sizeof(lis) + if n != (u - low + 1): + return None + else: + res = ([lis[1 - 1]] * n) + for i in range(2, n + 1): + temp = list(res) + temp[low - 1] = lis[i - 1] + res = temp + return res + + +def IfcLoopHeadToTail(aloop): + + p = True + n = sizeof(aloop.EdgeList) + for i in range(2, n + 1): + p = p and ((aloop.EdgeList[i - 1].EdgeEnd) == (aloop.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcMakeArrayOfArray(lis, low1, u1, low2, u2): + + if (u1 - low1 + 1) != sizeof(lis): + return None + if (u2 - low2 + 1) != (sizeof(lis[1 - 1])): + return None + res = ([IfcListToArray(lis[1 - 1],low2,u2)] * u1 - low1 + 1) + for i in range(2, hiindex(lis) + 1): + if (u2 - low2 + 1) != (sizeof(lis[i - 1])): + return None + temp = list(res) + temp[low1 - 1] = IfcListToArray(lis[i - 1],low2,u2) + res = temp + return res + + +def IfcMlsTotalThickness(layerset): + max = layerset.MaterialLayers[1 - 1].LayerThickness + if sizeof(layerset.MaterialLayers) > 1: + for i in range(2, hiindex(layerset.MaterialLayers) + 1): + max = max + (layerset.MaterialLayers[i - 1].LayerThickness) + return max + + +def IfcNormalise(arg): + + v = IfcDirection(DirectionRatios=[1.,0.]) + vec = IfcVector(Orientation=IfcDirection(DirectionRatios=[1.,0.]), Magnitude=1.) + + result = v + if not exists(arg): + return None + else: + if 'ifc4x3_rc1.ifcvector' in typeof(arg): + ndim = arg.Dim + v.DirectionRatios = arg.Orientation.DirectionRatios + vec.Magnitude = arg.Magnitude + vec.Orientation = v + if arg.Magnitude == 0.0: + return None + else: + vec.Magnitude = 1.0 + else: + ndim = arg.Dim + v.DirectionRatios = arg.DirectionRatios + mag = 0.0 + for i in range(1, ndim + 1): + mag = mag + ((v.DirectionRatios[i - 1]) * (v.DirectionRatios[i - 1])) + if mag > 0.0: + mag = sqrt(mag) + for i in range(1, ndim + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = (v.DirectionRatios[i - 1]) / mag + v.DirectionRatios = temp + if 'ifc4x3_rc1.ifcvector' in typeof(arg): + vec.Orientation = v + result = vec + else: + result = v + else: + return None + return result + + +def IfcOrthogonalComplement(vec): + + if (not exists(vec)) or (vec.Dim != 2): + return None + else: + result = IfcDirection(DirectionRatios=[-vec.DirectionRatios[2 - 1],vec.DirectionRatios[1 - 1]]) + return result + + +def IfcPathHeadToTail(apath): + n = 0 + p = unknown + n = sizeof(apath.EdgeList) + for i in range(2, n + 1): + p = p and ((apath.EdgeList[i - 1].EdgeEnd) == (apath.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcPointListDim(pointlist): + + if 'ifc4x3_rc1.ifccartesianpointlist2d' in typeof(pointlist): + return 2 + if 'ifc4x3_rc1.ifccartesianpointlist3d' in typeof(pointlist): + return 3 + return None + + +def IfcSameAxis2Placement(ap1, ap2, epsilon): + + return (IfcSameDirection(ap1.P[1 - 1],ap2.P[1 - 1],epsilon)) and (IfcSameDirection(ap1.P[2 - 1],ap2.P[2 - 1],epsilon)) and IfcSameCartesianPoint(ap1.Location,ap1.Location,epsilon) + + +def IfcSameCartesianPoint(cp1, cp2, epsilon): + cp1x = cp1.Coordinates[1 - 1] + cp1y = cp1.Coordinates[2 - 1] + cp1z = 0 + cp2x = cp2.Coordinates[1 - 1] + cp2y = cp2.Coordinates[2 - 1] + cp2z = 0 + if sizeof(cp1.Coordinates) > 2: + cp1z = cp1.Coordinates[3 - 1] + if sizeof(cp2.Coordinates) > 2: + cp2z = cp2.Coordinates[3 - 1] + return IfcSameValue(cp1x,cp2x,epsilon) and IfcSameValue(cp1y,cp2y,epsilon) and IfcSameValue(cp1z,cp2z,epsilon) + + +def IfcSameDirection(dir1, dir2, epsilon): + dir1x = dir1.DirectionRatios[1 - 1] + dir1y = dir1.DirectionRatios[2 - 1] + dir1z = 0 + dir2x = dir2.DirectionRatios[1 - 1] + dir2y = dir2.DirectionRatios[2 - 1] + dir2z = 0 + if sizeof(dir1.DirectionRatios) > 2: + dir1z = dir1.DirectionRatios[3 - 1] + if sizeof(dir2.DirectionRatios) > 2: + dir2z = dir2.DirectionRatios[3 - 1] + return IfcSameValue(dir1x,dir2x,epsilon) and IfcSameValue(dir1y,dir2y,epsilon) and IfcSameValue(dir1z,dir2z,epsilon) + + +def IfcSameValidPrecision(epsilon1, epsilon2): + + defaulteps = 0.000001 + derivationofeps = 1.001 + uppereps = 1.0 + valideps1 = nvl(epsilon1,defaulteps) + valideps2 = nvl(epsilon2,defaulteps) + return (0.0 < valideps1) and (valideps1 <= (derivationofeps * valideps2)) and (valideps2 <= (derivationofeps * valideps1)) and (valideps2 < uppereps) + + +def IfcSameValue(value1, value2, epsilon): + + defaulteps = 0.000001 + valideps = nvl(epsilon,defaulteps) + return ((value1 + valideps) > value2) and (value1 < (value2 + valideps)) + + +def IfcScalarTimesVector(scalar, vec): + + + + if (not exists(scalar)) or (not exists(vec)): + return None + else: + if 'ifc4x3_rc1.ifcvector' in typeof(vec): + v = vec.Orientation + mag = scalar * vec.Magnitude + else: + v = vec + mag = scalar + if mag < 0.0: + for i in range(1, sizeof(v.DirectionRatios) + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = -v.DirectionRatios[i - 1] + v.DirectionRatios = temp + mag = -mag + result = IfcVector(Orientation=IfcNormalise(v), Magnitude=mag) + return result + + +def IfcSecondProjAxis(zaxis, xaxis, arg): + + + + if not exists(arg): + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + v = arg + temp = IfcScalarTimesVector(IfcDotProduct(v,zaxis),zaxis) + yaxis = IfcVectorDifference(v,temp) + temp = IfcScalarTimesVector(IfcDotProduct(v,xaxis),xaxis) + yaxis = IfcVectorDifference(yaxis,temp) + yaxis = IfcNormalise(yaxis) + return yaxis.Orientation + + +def IfcShapeRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'point': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifcpoint' in typeof(temp)]) + elif reptype.lower() == 'pointcloud': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifccartesianpointlist3d' in typeof(temp)]) + elif reptype.lower() == 'curve': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifccurve' in typeof(temp)]) + elif reptype.lower() == 'curve2d': + count = sizeof([temp for temp in items if ('ifc4x3_rc1.ifccurve' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'curve3d': + count = sizeof([temp for temp in items if ('ifc4x3_rc1.ifccurve' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'surface': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifcsurface' in typeof(temp)]) + elif reptype.lower() == 'surface2d': + count = sizeof([temp for temp in items if ('ifc4x3_rc1.ifcsurface' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'surface3d': + count = sizeof([temp for temp in items if ('ifc4x3_rc1.ifcsurface' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'fillarea': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifcannotationfillarea' in typeof(temp)]) + elif reptype.lower() == 'text': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifctextliteral' in typeof(temp)]) + elif reptype.lower() == 'advancedsurface': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifcbsplinesurface' in typeof(temp)]) + elif reptype.lower() == 'annotation2d': + count = sizeof([temp for temp in items if (sizeof(typeof(temp) * ['ifc4x3_rc1.ifcpoint','ifc4x3_rc1.ifccurve','ifc4x3_rc1.ifcgeometriccurveset','ifc4x3_rc1.ifcannotationfillarea','ifc4x3_rc1.ifctextliteral'])) == 1]) + elif reptype.lower() == 'geometricset': + count = sizeof([temp for temp in items if ('ifc4x3_rc1.ifcgeometricset' in typeof(temp)) or ('ifc4x3_rc1.ifcpoint' in typeof(temp)) or ('ifc4x3_rc1.ifccurve' in typeof(temp)) or ('ifc4x3_rc1.ifcsurface' in typeof(temp))]) + elif reptype.lower() == 'geometriccurveset': + count = sizeof([temp for temp in items if ('ifc4x3_rc1.ifcgeometriccurveset' in typeof(temp)) or ('ifc4x3_rc1.ifcgeometricset' in typeof(temp)) or ('ifc4x3_rc1.ifcpoint' in typeof(temp)) or ('ifc4x3_rc1.ifccurve' in typeof(temp))]) + for i in range(1, hiindex(items) + 1): + if 'ifc4x3_rc1.ifcgeometricset' in (typeof(items[i - 1])): + if (sizeof([temp for temp in items[i - 1].Elements if 'ifc4x3_rc1.ifcsurface' in typeof(temp)])) > 0: + count = count - 1 + elif reptype.lower() == 'tessellation': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifctessellateditem' in typeof(temp)]) + elif reptype.lower() == 'surfaceorsolidmodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc1.ifctessellateditem','ifc4x3_rc1.ifcshellbasedsurfacemodel','ifc4x3_rc1.ifcfacebasedsurfacemodel','ifc4x3_rc1.ifcsolidmodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'surfacemodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc1.ifctessellateditem','ifc4x3_rc1.ifcshellbasedsurfacemodel','ifc4x3_rc1.ifcfacebasedsurfacemodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'solidmodel': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifcsolidmodel' in typeof(temp)]) + elif reptype.lower() == 'sweptsolid': + count = sizeof([temp for temp in items if ((sizeof(['ifc4x3_rc1.ifcextrudedareasolid','ifc4x3_rc1.ifcrevolvedareasolid'] * typeof(temp))) >= 1) and ((sizeof(['ifc4x3_rc1.ifcextrudedareasolidtapered','ifc4x3_rc1.ifcrevolvedareasolidtapered'] * typeof(temp))) == 0)]) + elif reptype.lower() == 'advancedsweptsolid': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc1.ifcsweptareasolid','ifc4x3_rc1.ifcsweptdisksolid'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'csg': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc1.ifcbooleanresult','ifc4x3_rc1.ifccsgprimitive3d','ifc4x3_rc1.ifccsgsolid'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'clipping': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc1.ifccsgsolid','ifc4x3_rc1.ifcbooleanclippingresult'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'brep': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifcfacetedbrep' in typeof(temp)]) + elif reptype.lower() == 'advancedbrep': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifcmanifoldsolidbrep' in typeof(temp)]) + elif reptype.lower() == 'boundingbox': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifcboundingbox' in typeof(temp)]) + if sizeof(items) > 1: + count = 0 + elif reptype.lower() == 'sectionedspine': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifcsectionedspine' in typeof(temp)]) + elif reptype.lower() == 'lightsource': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifclightsource' in typeof(temp)]) + elif reptype.lower() == 'mappedrepresentation': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifcmappeditem' in typeof(temp)]) + else: + return None + return count == sizeof(items) + + +def IfcSurfaceWeightsPositive(b): + result = True + weights = b.Weights + for i in range(0, b.UUpper + 1): + for j in range(0, b.VUpper + 1): + if (weights[i - 1][j - 1]) <= 0.0: + result = False + return result + return result + + +def IfcTaperedSweptAreaProfiles(startarea, endarea): + result = False + if 'ifc4x3_rc1.ifcparameterizedprofiledef' in typeof(startarea): + if 'ifc4x3_rc1.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = typeof(startarea) == typeof(endarea) + else: + if 'ifc4x3_rc1.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = False + return result + + +def IfcTopologyRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'vertex': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifcvertex' in typeof(temp)]) + elif reptype.lower() == 'edge': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifcedge' in typeof(temp)]) + elif reptype.lower() == 'path': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifcpath' in typeof(temp)]) + elif reptype.lower() == 'face': + count = sizeof([temp for temp in items if 'ifc4x3_rc1.ifcface' in typeof(temp)]) + elif reptype.lower() == 'shell': + count = sizeof([temp for temp in items if ('ifc4x3_rc1.ifcopenshell' in typeof(temp)) or ('ifc4x3_rc1.ifcclosedshell' in typeof(temp))]) + elif reptype.lower() == 'undefined': + return True + else: + return None + return count == sizeof(items) + + +def IfcUniqueDefinitionNames(relations): + + + properties = express_set([]) + + if sizeof(relations) == 0: + return True + for i in range(1, hiindex(relations) + 1): + definition = relations[i - 1].RelatingPropertyDefinition + if 'ifc4x3_rc1.ifcpropertysetdefinition' in typeof(definition): + properties = properties + definition + else: + if 'ifc4x3_rc1.ifcpropertysetdefinitionset' in typeof(definition): + definitionset = definition + for j in range(1, hiindex(definitionset) + 1): + properties = properties + (definitionset[j - 1]) + result = IfcUniquePropertySetNames(properties) + return result + + +def IfcUniquePropertyName(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniquePropertySetNames(properties): + names = express_set([]) + unnamed = 0 + for i in range(1, hiindex(properties) + 1): + if 'ifc4x3_rc1.ifcpropertyset' in (typeof(properties[i - 1])): + names = names + (properties[i - 1].Name) + else: + unnamed = unnamed + 1 + return (sizeof(names) + unnamed) == sizeof(properties) + + +def IfcUniquePropertyTemplateNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniqueQuantityNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcVectorDifference(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x3_rc1.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x3_rc1.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) - (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + +def IfcVectorSum(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x3_rc1.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x3_rc1.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) + (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + diff --git a/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_RC2.py b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_RC2.py new file mode 100644 index 0000000000..36db94892f --- /dev/null +++ b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_RC2.py @@ -0,0 +1,24827 @@ +import ifcopenshell + +def exists(v): + if callable(v): + try: return v() is not None + except IndexError as e: return False + else: return v is not None + + + +def nvl(v, default): return v if v is not None else default + + +sizeof = len +hiindex = len +blength = len +loindex = lambda x: 1 +from math import * +unknown = 'UNKNOWN' + +def usedin(inst, ref_name): + if inst is None: + return [] + _, __, attr = ref_name.split('.') + def filter(): + for ref, attr_idx in inst.wrapped_data.file.get_inverse(inst, allow_duplicate=True, with_attribute_indices=True): + if ref.wrapped_data.get_attribute_names()[attr_idx].lower() == attr: + yield ref + return list(filter()) + + +class express_set(set): + def __rmul__(self, other): + return express_set(set(other) & self) + def __add__(self, other): + def make_list(v): + # Comply with 12.6.3 Union operator + if isinstance(v, (list, tuple, set, express_set)): + return list(v) + else: + return [v] + return express_set(list(self) + make_list(other)) + __radd__ = __add__ + def __repr__(self): + return repr(set(self)) + + +def typeof(inst): + if not inst: + # If V evaluates to indeterminate (?), an empty set is returned. + return express_set([]) + schema_name = inst.is_a(True).split('.')[0].lower() + def inner(): + decl = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(inst.is_a()) + while decl: + yield '.'.join((schema_name, decl.name().lower())) + decl = decl.supertype() + return express_set(inner()) + +class enum_namespace: + def __getattr__(self, k): + return k.upper() + + +IfcActionRequestTypeEnum = enum_namespace() + + +email = IfcActionRequestTypeEnum.EMAIL + + +fax = IfcActionRequestTypeEnum.FAX + + +phone = IfcActionRequestTypeEnum.PHONE + + +post = IfcActionRequestTypeEnum.POST + + +verbal = IfcActionRequestTypeEnum.VERBAL + + +userdefined = IfcActionRequestTypeEnum.USERDEFINED + + +notdefined = IfcActionRequestTypeEnum.NOTDEFINED + + +IfcActionSourceTypeEnum = enum_namespace() + + +dead_load_g = IfcActionSourceTypeEnum.DEAD_LOAD_G + + +completion_g1 = IfcActionSourceTypeEnum.COMPLETION_G1 + + +live_load_q = IfcActionSourceTypeEnum.LIVE_LOAD_Q + + +snow_s = IfcActionSourceTypeEnum.SNOW_S + + +wind_w = IfcActionSourceTypeEnum.WIND_W + + +prestressing_p = IfcActionSourceTypeEnum.PRESTRESSING_P + + +settlement_u = IfcActionSourceTypeEnum.SETTLEMENT_U + + +temperature_t = IfcActionSourceTypeEnum.TEMPERATURE_T + + +earthquake_e = IfcActionSourceTypeEnum.EARTHQUAKE_E + + +fire = IfcActionSourceTypeEnum.FIRE + + +impulse = IfcActionSourceTypeEnum.IMPULSE + + +impact = IfcActionSourceTypeEnum.IMPACT + + +transport = IfcActionSourceTypeEnum.TRANSPORT + + +erection = IfcActionSourceTypeEnum.ERECTION + + +propping = IfcActionSourceTypeEnum.PROPPING + + +system_imperfection = IfcActionSourceTypeEnum.SYSTEM_IMPERFECTION + + +shrinkage = IfcActionSourceTypeEnum.SHRINKAGE + + +creep = IfcActionSourceTypeEnum.CREEP + + +lack_of_fit = IfcActionSourceTypeEnum.LACK_OF_FIT + + +buoyancy = IfcActionSourceTypeEnum.BUOYANCY + + +ice = IfcActionSourceTypeEnum.ICE + + +current = IfcActionSourceTypeEnum.CURRENT + + +wave = IfcActionSourceTypeEnum.WAVE + + +rain = IfcActionSourceTypeEnum.RAIN + + +brakes = IfcActionSourceTypeEnum.BRAKES + + +userdefined = IfcActionSourceTypeEnum.USERDEFINED + + +notdefined = IfcActionSourceTypeEnum.NOTDEFINED + + +IfcActionTypeEnum = enum_namespace() + + +permanent_g = IfcActionTypeEnum.PERMANENT_G + + +variable_q = IfcActionTypeEnum.VARIABLE_Q + + +extraordinary_a = IfcActionTypeEnum.EXTRAORDINARY_A + + +userdefined = IfcActionTypeEnum.USERDEFINED + + +notdefined = IfcActionTypeEnum.NOTDEFINED + + +IfcActuatorTypeEnum = enum_namespace() + + +electricactuator = IfcActuatorTypeEnum.ELECTRICACTUATOR + + +handoperatedactuator = IfcActuatorTypeEnum.HANDOPERATEDACTUATOR + + +hydraulicactuator = IfcActuatorTypeEnum.HYDRAULICACTUATOR + + +pneumaticactuator = IfcActuatorTypeEnum.PNEUMATICACTUATOR + + +thermostaticactuator = IfcActuatorTypeEnum.THERMOSTATICACTUATOR + + +userdefined = IfcActuatorTypeEnum.USERDEFINED + + +notdefined = IfcActuatorTypeEnum.NOTDEFINED + + +IfcAddressTypeEnum = enum_namespace() + + +office = IfcAddressTypeEnum.OFFICE + + +site = IfcAddressTypeEnum.SITE + + +home = IfcAddressTypeEnum.HOME + + +distributionpoint = IfcAddressTypeEnum.DISTRIBUTIONPOINT + + +userdefined = IfcAddressTypeEnum.USERDEFINED + + +IfcAirTerminalBoxTypeEnum = enum_namespace() + + +constantflow = IfcAirTerminalBoxTypeEnum.CONSTANTFLOW + + +variableflowpressuredependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREDEPENDANT + + +variableflowpressureindependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREINDEPENDANT + + +userdefined = IfcAirTerminalBoxTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalBoxTypeEnum.NOTDEFINED + + +IfcAirTerminalTypeEnum = enum_namespace() + + +diffuser = IfcAirTerminalTypeEnum.DIFFUSER + + +grille = IfcAirTerminalTypeEnum.GRILLE + + +louvre = IfcAirTerminalTypeEnum.LOUVRE + + +register = IfcAirTerminalTypeEnum.REGISTER + + +userdefined = IfcAirTerminalTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalTypeEnum.NOTDEFINED + + +IfcAirToAirHeatRecoveryTypeEnum = enum_namespace() + + +fixedplatecounterflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECOUNTERFLOWEXCHANGER + + +fixedplatecrossflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECROSSFLOWEXCHANGER + + +fixedplateparallelflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATEPARALLELFLOWEXCHANGER + + +rotarywheel = IfcAirToAirHeatRecoveryTypeEnum.ROTARYWHEEL + + +runaroundcoilloop = IfcAirToAirHeatRecoveryTypeEnum.RUNAROUNDCOILLOOP + + +heatpipe = IfcAirToAirHeatRecoveryTypeEnum.HEATPIPE + + +twintowerenthalpyrecoveryloops = IfcAirToAirHeatRecoveryTypeEnum.TWINTOWERENTHALPYRECOVERYLOOPS + + +thermosiphonsealedtubeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONSEALEDTUBEHEATEXCHANGERS + + +thermosiphoncoiltypeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONCOILTYPEHEATEXCHANGERS + + +userdefined = IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED + + +notdefined = IfcAirToAirHeatRecoveryTypeEnum.NOTDEFINED + + +IfcAlarmTypeEnum = enum_namespace() + + +bell = IfcAlarmTypeEnum.BELL + + +breakglassbutton = IfcAlarmTypeEnum.BREAKGLASSBUTTON + + +light = IfcAlarmTypeEnum.LIGHT + + +manualpullbox = IfcAlarmTypeEnum.MANUALPULLBOX + + +siren = IfcAlarmTypeEnum.SIREN + + +whistle = IfcAlarmTypeEnum.WHISTLE + + +railwaycrocodile = IfcAlarmTypeEnum.RAILWAYCROCODILE + + +railwaydetonator = IfcAlarmTypeEnum.RAILWAYDETONATOR + + +userdefined = IfcAlarmTypeEnum.USERDEFINED + + +notdefined = IfcAlarmTypeEnum.NOTDEFINED + + +IfcAlignmentCantSegmentTypeEnum = enum_namespace() + + +constantcant = IfcAlignmentCantSegmentTypeEnum.CONSTANTCANT + + +lineartransition = IfcAlignmentCantSegmentTypeEnum.LINEARTRANSITION + + +biquadraticparabola = IfcAlignmentCantSegmentTypeEnum.BIQUADRATICPARABOLA + + +blosscurve = IfcAlignmentCantSegmentTypeEnum.BLOSSCURVE + + +cosinecurve = IfcAlignmentCantSegmentTypeEnum.COSINECURVE + + +sinecurve = IfcAlignmentCantSegmentTypeEnum.SINECURVE + + +viennesebend = IfcAlignmentCantSegmentTypeEnum.VIENNESEBEND + + +IfcAlignmentHorizontalSegmentTypeEnum = enum_namespace() + + +line = IfcAlignmentHorizontalSegmentTypeEnum.LINE + + +circulararc = IfcAlignmentHorizontalSegmentTypeEnum.CIRCULARARC + + +clothoid = IfcAlignmentHorizontalSegmentTypeEnum.CLOTHOID + + +cubicspiral = IfcAlignmentHorizontalSegmentTypeEnum.CUBICSPIRAL + + +biquadraticparabola = IfcAlignmentHorizontalSegmentTypeEnum.BIQUADRATICPARABOLA + + +blosscurve = IfcAlignmentHorizontalSegmentTypeEnum.BLOSSCURVE + + +cosinecurve = IfcAlignmentHorizontalSegmentTypeEnum.COSINECURVE + + +sinecurve = IfcAlignmentHorizontalSegmentTypeEnum.SINECURVE + + +viennesebend = IfcAlignmentHorizontalSegmentTypeEnum.VIENNESEBEND + + +IfcAlignmentTypeEnum = enum_namespace() + + +userdefined = IfcAlignmentTypeEnum.USERDEFINED + + +notdefined = IfcAlignmentTypeEnum.NOTDEFINED + + +IfcAlignmentVerticalSegmentTypeEnum = enum_namespace() + + +constantgradient = IfcAlignmentVerticalSegmentTypeEnum.CONSTANTGRADIENT + + +circulararc = IfcAlignmentVerticalSegmentTypeEnum.CIRCULARARC + + +parabolicarc = IfcAlignmentVerticalSegmentTypeEnum.PARABOLICARC + + +clothoid = IfcAlignmentVerticalSegmentTypeEnum.CLOTHOID + + +IfcAnalysisModelTypeEnum = enum_namespace() + + +in_plane_loading_2d = IfcAnalysisModelTypeEnum.IN_PLANE_LOADING_2D + + +out_plane_loading_2d = IfcAnalysisModelTypeEnum.OUT_PLANE_LOADING_2D + + +loading_3d = IfcAnalysisModelTypeEnum.LOADING_3D + + +userdefined = IfcAnalysisModelTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisModelTypeEnum.NOTDEFINED + + +IfcAnalysisTheoryTypeEnum = enum_namespace() + + +first_order_theory = IfcAnalysisTheoryTypeEnum.FIRST_ORDER_THEORY + + +second_order_theory = IfcAnalysisTheoryTypeEnum.SECOND_ORDER_THEORY + + +third_order_theory = IfcAnalysisTheoryTypeEnum.THIRD_ORDER_THEORY + + +full_nonlinear_theory = IfcAnalysisTheoryTypeEnum.FULL_NONLINEAR_THEORY + + +userdefined = IfcAnalysisTheoryTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisTheoryTypeEnum.NOTDEFINED + + +IfcAnnotationTypeEnum = enum_namespace() + + +assumedpoint = IfcAnnotationTypeEnum.ASSUMEDPOINT + + +asbuiltarea = IfcAnnotationTypeEnum.ASBUILTAREA + + +asbuiltline = IfcAnnotationTypeEnum.ASBUILTLINE + + +non_physical_signal = IfcAnnotationTypeEnum.NON_PHYSICAL_SIGNAL + + +assumedline = IfcAnnotationTypeEnum.ASSUMEDLINE + + +widthevent = IfcAnnotationTypeEnum.WIDTHEVENT + + +assumedarea = IfcAnnotationTypeEnum.ASSUMEDAREA + + +superelevationevent = IfcAnnotationTypeEnum.SUPERELEVATIONEVENT + + +asbuiltpoint = IfcAnnotationTypeEnum.ASBUILTPOINT + + +userdefined = IfcAnnotationTypeEnum.USERDEFINED + + +notdefined = IfcAnnotationTypeEnum.NOTDEFINED + + +IfcArithmeticOperatorEnum = enum_namespace() + + +add = IfcArithmeticOperatorEnum.ADD + + +divide = IfcArithmeticOperatorEnum.DIVIDE + + +multiply = IfcArithmeticOperatorEnum.MULTIPLY + + +subtract = IfcArithmeticOperatorEnum.SUBTRACT + + +IfcAssemblyPlaceEnum = enum_namespace() + + +site = IfcAssemblyPlaceEnum.SITE + + +factory = IfcAssemblyPlaceEnum.FACTORY + + +notdefined = IfcAssemblyPlaceEnum.NOTDEFINED + + +IfcAudioVisualApplianceTypeEnum = enum_namespace() + + +amplifier = IfcAudioVisualApplianceTypeEnum.AMPLIFIER + + +camera = IfcAudioVisualApplianceTypeEnum.CAMERA + + +display = IfcAudioVisualApplianceTypeEnum.DISPLAY + + +microphone = IfcAudioVisualApplianceTypeEnum.MICROPHONE + + +player = IfcAudioVisualApplianceTypeEnum.PLAYER + + +projector = IfcAudioVisualApplianceTypeEnum.PROJECTOR + + +receiver = IfcAudioVisualApplianceTypeEnum.RECEIVER + + +speaker = IfcAudioVisualApplianceTypeEnum.SPEAKER + + +switcher = IfcAudioVisualApplianceTypeEnum.SWITCHER + + +telephone = IfcAudioVisualApplianceTypeEnum.TELEPHONE + + +tuner = IfcAudioVisualApplianceTypeEnum.TUNER + + +railway_communication_terminal = IfcAudioVisualApplianceTypeEnum.RAILWAY_COMMUNICATION_TERMINAL + + +userdefined = IfcAudioVisualApplianceTypeEnum.USERDEFINED + + +notdefined = IfcAudioVisualApplianceTypeEnum.NOTDEFINED + + +IfcBSplineCurveForm = enum_namespace() + + +polyline_form = IfcBSplineCurveForm.POLYLINE_FORM + + +circular_arc = IfcBSplineCurveForm.CIRCULAR_ARC + + +elliptic_arc = IfcBSplineCurveForm.ELLIPTIC_ARC + + +parabolic_arc = IfcBSplineCurveForm.PARABOLIC_ARC + + +hyperbolic_arc = IfcBSplineCurveForm.HYPERBOLIC_ARC + + +unspecified = IfcBSplineCurveForm.UNSPECIFIED + + +IfcBSplineSurfaceForm = enum_namespace() + + +plane_surf = IfcBSplineSurfaceForm.PLANE_SURF + + +cylindrical_surf = IfcBSplineSurfaceForm.CYLINDRICAL_SURF + + +conical_surf = IfcBSplineSurfaceForm.CONICAL_SURF + + +spherical_surf = IfcBSplineSurfaceForm.SPHERICAL_SURF + + +toroidal_surf = IfcBSplineSurfaceForm.TOROIDAL_SURF + + +surf_of_revolution = IfcBSplineSurfaceForm.SURF_OF_REVOLUTION + + +ruled_surf = IfcBSplineSurfaceForm.RULED_SURF + + +generalised_cone = IfcBSplineSurfaceForm.GENERALISED_CONE + + +quadric_surf = IfcBSplineSurfaceForm.QUADRIC_SURF + + +surf_of_linear_extrusion = IfcBSplineSurfaceForm.SURF_OF_LINEAR_EXTRUSION + + +unspecified = IfcBSplineSurfaceForm.UNSPECIFIED + + +IfcBeamTypeEnum = enum_namespace() + + +beam = IfcBeamTypeEnum.BEAM + + +joist = IfcBeamTypeEnum.JOIST + + +hollowcore = IfcBeamTypeEnum.HOLLOWCORE + + +lintel = IfcBeamTypeEnum.LINTEL + + +spandrel = IfcBeamTypeEnum.SPANDREL + + +t_beam = IfcBeamTypeEnum.T_BEAM + + +girder_segment = IfcBeamTypeEnum.GIRDER_SEGMENT + + +diaphragm = IfcBeamTypeEnum.DIAPHRAGM + + +piercap = IfcBeamTypeEnum.PIERCAP + + +hatstone = IfcBeamTypeEnum.HATSTONE + + +cornice = IfcBeamTypeEnum.CORNICE + + +edgebeam = IfcBeamTypeEnum.EDGEBEAM + + +userdefined = IfcBeamTypeEnum.USERDEFINED + + +notdefined = IfcBeamTypeEnum.NOTDEFINED + + +IfcBearingTypeDisplacementEnum = enum_namespace() + + +fixed_movement = IfcBearingTypeDisplacementEnum.FIXED_MOVEMENT + + +guided_longitudinal = IfcBearingTypeDisplacementEnum.GUIDED_LONGITUDINAL + + +guided_transversal = IfcBearingTypeDisplacementEnum.GUIDED_TRANSVERSAL + + +free_movement = IfcBearingTypeDisplacementEnum.FREE_MOVEMENT + + +notdefined = IfcBearingTypeDisplacementEnum.NOTDEFINED + + +IfcBearingTypeEnum = enum_namespace() + + +cylindrical = IfcBearingTypeEnum.CYLINDRICAL + + +spherical = IfcBearingTypeEnum.SPHERICAL + + +elastomeric = IfcBearingTypeEnum.ELASTOMERIC + + +pot = IfcBearingTypeEnum.POT + + +guide = IfcBearingTypeEnum.GUIDE + + +rocker = IfcBearingTypeEnum.ROCKER + + +roller = IfcBearingTypeEnum.ROLLER + + +disk = IfcBearingTypeEnum.DISK + + +userdefined = IfcBearingTypeEnum.USERDEFINED + + +notdefined = IfcBearingTypeEnum.NOTDEFINED + + +IfcBenchmarkEnum = enum_namespace() + + +greaterthan = IfcBenchmarkEnum.GREATERTHAN + + +greaterthanorequalto = IfcBenchmarkEnum.GREATERTHANOREQUALTO + + +lessthan = IfcBenchmarkEnum.LESSTHAN + + +lessthanorequalto = IfcBenchmarkEnum.LESSTHANOREQUALTO + + +equalto = IfcBenchmarkEnum.EQUALTO + + +notequalto = IfcBenchmarkEnum.NOTEQUALTO + + +includes = IfcBenchmarkEnum.INCLUDES + + +notincludes = IfcBenchmarkEnum.NOTINCLUDES + + +includedin = IfcBenchmarkEnum.INCLUDEDIN + + +notincludedin = IfcBenchmarkEnum.NOTINCLUDEDIN + + +IfcBoilerTypeEnum = enum_namespace() + + +water = IfcBoilerTypeEnum.WATER + + +steam = IfcBoilerTypeEnum.STEAM + + +userdefined = IfcBoilerTypeEnum.USERDEFINED + + +notdefined = IfcBoilerTypeEnum.NOTDEFINED + + +IfcBooleanOperator = enum_namespace() + + +union = IfcBooleanOperator.UNION + + +intersection = IfcBooleanOperator.INTERSECTION + + +difference = IfcBooleanOperator.DIFFERENCE + + +IfcBridgePartTypeEnum = enum_namespace() + + +abutment = IfcBridgePartTypeEnum.ABUTMENT + + +deck = IfcBridgePartTypeEnum.DECK + + +deck_segment = IfcBridgePartTypeEnum.DECK_SEGMENT + + +foundation = IfcBridgePartTypeEnum.FOUNDATION + + +pier = IfcBridgePartTypeEnum.PIER + + +pier_segment = IfcBridgePartTypeEnum.PIER_SEGMENT + + +pylon = IfcBridgePartTypeEnum.PYLON + + +substructure = IfcBridgePartTypeEnum.SUBSTRUCTURE + + +superstructure = IfcBridgePartTypeEnum.SUPERSTRUCTURE + + +surfacestructure = IfcBridgePartTypeEnum.SURFACESTRUCTURE + + +userdefined = IfcBridgePartTypeEnum.USERDEFINED + + +notdefined = IfcBridgePartTypeEnum.NOTDEFINED + + +IfcBridgeTypeEnum = enum_namespace() + + +arched = IfcBridgeTypeEnum.ARCHED + + +cable_stayed = IfcBridgeTypeEnum.CABLE_STAYED + + +cantilever = IfcBridgeTypeEnum.CANTILEVER + + +culvert = IfcBridgeTypeEnum.CULVERT + + +framework = IfcBridgeTypeEnum.FRAMEWORK + + +girder = IfcBridgeTypeEnum.GIRDER + + +suspension = IfcBridgeTypeEnum.SUSPENSION + + +truss = IfcBridgeTypeEnum.TRUSS + + +userdefined = IfcBridgeTypeEnum.USERDEFINED + + +notdefined = IfcBridgeTypeEnum.NOTDEFINED + + +IfcBuildingElementPartTypeEnum = enum_namespace() + + +insulation = IfcBuildingElementPartTypeEnum.INSULATION + + +precastpanel = IfcBuildingElementPartTypeEnum.PRECASTPANEL + + +apron = IfcBuildingElementPartTypeEnum.APRON + + +armourunit = IfcBuildingElementPartTypeEnum.ARMOURUNIT + + +safetycage = IfcBuildingElementPartTypeEnum.SAFETYCAGE + + +userdefined = IfcBuildingElementPartTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementPartTypeEnum.NOTDEFINED + + +IfcBuildingElementProxyTypeEnum = enum_namespace() + + +complex = IfcBuildingElementProxyTypeEnum.COMPLEX + + +element = IfcBuildingElementProxyTypeEnum.ELEMENT + + +partial = IfcBuildingElementProxyTypeEnum.PARTIAL + + +provisionforvoid = IfcBuildingElementProxyTypeEnum.PROVISIONFORVOID + + +provisionforspace = IfcBuildingElementProxyTypeEnum.PROVISIONFORSPACE + + +userdefined = IfcBuildingElementProxyTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementProxyTypeEnum.NOTDEFINED + + +IfcBuildingSystemTypeEnum = enum_namespace() + + +fenestration = IfcBuildingSystemTypeEnum.FENESTRATION + + +foundation = IfcBuildingSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuildingSystemTypeEnum.LOADBEARING + + +outershell = IfcBuildingSystemTypeEnum.OUTERSHELL + + +shading = IfcBuildingSystemTypeEnum.SHADING + + +transport = IfcBuildingSystemTypeEnum.TRANSPORT + + +reinforcing = IfcBuildingSystemTypeEnum.REINFORCING + + +prestressing = IfcBuildingSystemTypeEnum.PRESTRESSING + + +erosionprevention = IfcBuildingSystemTypeEnum.EROSIONPREVENTION + + +userdefined = IfcBuildingSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuildingSystemTypeEnum.NOTDEFINED + + +IfcBuiltSystemTypeEnum = enum_namespace() + + +reinforcing = IfcBuiltSystemTypeEnum.REINFORCING + + +mooring = IfcBuiltSystemTypeEnum.MOORING + + +outershell = IfcBuiltSystemTypeEnum.OUTERSHELL + + +trackcircuit = IfcBuiltSystemTypeEnum.TRACKCIRCUIT + + +erosionprevention = IfcBuiltSystemTypeEnum.EROSIONPREVENTION + + +foundation = IfcBuiltSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuiltSystemTypeEnum.LOADBEARING + + +shading = IfcBuiltSystemTypeEnum.SHADING + + +fenestration = IfcBuiltSystemTypeEnum.FENESTRATION + + +mooringsystem = IfcBuiltSystemTypeEnum.MOORINGSYSTEM + + +transport = IfcBuiltSystemTypeEnum.TRANSPORT + + +prestressing = IfcBuiltSystemTypeEnum.PRESTRESSING + + +userdefined = IfcBuiltSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuiltSystemTypeEnum.NOTDEFINED + + +IfcBurnerTypeEnum = enum_namespace() + + +userdefined = IfcBurnerTypeEnum.USERDEFINED + + +notdefined = IfcBurnerTypeEnum.NOTDEFINED + + +IfcCableCarrierFittingTypeEnum = enum_namespace() + + +bend = IfcCableCarrierFittingTypeEnum.BEND + + +cross = IfcCableCarrierFittingTypeEnum.CROSS + + +reducer = IfcCableCarrierFittingTypeEnum.REDUCER + + +tee = IfcCableCarrierFittingTypeEnum.TEE + + +userdefined = IfcCableCarrierFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierFittingTypeEnum.NOTDEFINED + + +IfcCableCarrierSegmentTypeEnum = enum_namespace() + + +cableladdersegment = IfcCableCarrierSegmentTypeEnum.CABLELADDERSEGMENT + + +cabletraysegment = IfcCableCarrierSegmentTypeEnum.CABLETRAYSEGMENT + + +cabletrunkingsegment = IfcCableCarrierSegmentTypeEnum.CABLETRUNKINGSEGMENT + + +conduitsegment = IfcCableCarrierSegmentTypeEnum.CONDUITSEGMENT + + +cablebracket = IfcCableCarrierSegmentTypeEnum.CABLEBRACKET + + +catenarywire = IfcCableCarrierSegmentTypeEnum.CATENARYWIRE + + +dropper = IfcCableCarrierSegmentTypeEnum.DROPPER + + +userdefined = IfcCableCarrierSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierSegmentTypeEnum.NOTDEFINED + + +IfcCableFittingTypeEnum = enum_namespace() + + +connector = IfcCableFittingTypeEnum.CONNECTOR + + +entry = IfcCableFittingTypeEnum.ENTRY + + +exit = IfcCableFittingTypeEnum.EXIT + + +junction = IfcCableFittingTypeEnum.JUNCTION + + +transition = IfcCableFittingTypeEnum.TRANSITION + + +fanout = IfcCableFittingTypeEnum.FANOUT + + +userdefined = IfcCableFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableFittingTypeEnum.NOTDEFINED + + +IfcCableSegmentTypeEnum = enum_namespace() + + +busbarsegment = IfcCableSegmentTypeEnum.BUSBARSEGMENT + + +cablesegment = IfcCableSegmentTypeEnum.CABLESEGMENT + + +conductorsegment = IfcCableSegmentTypeEnum.CONDUCTORSEGMENT + + +coresegment = IfcCableSegmentTypeEnum.CORESEGMENT + + +contactwiresegment = IfcCableSegmentTypeEnum.CONTACTWIRESEGMENT + + +fibersegment = IfcCableSegmentTypeEnum.FIBERSEGMENT + + +fibertube = IfcCableSegmentTypeEnum.FIBERTUBE + + +opticalcablesegment = IfcCableSegmentTypeEnum.OPTICALCABLESEGMENT + + +stitchwire = IfcCableSegmentTypeEnum.STITCHWIRE + + +wirepairsegment = IfcCableSegmentTypeEnum.WIREPAIRSEGMENT + + +userdefined = IfcCableSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableSegmentTypeEnum.NOTDEFINED + + +IfcCaissonFoundationTypeEnum = enum_namespace() + + +well = IfcCaissonFoundationTypeEnum.WELL + + +caisson = IfcCaissonFoundationTypeEnum.CAISSON + + +userdefined = IfcCaissonFoundationTypeEnum.USERDEFINED + + +notdefined = IfcCaissonFoundationTypeEnum.NOTDEFINED + + +IfcChangeActionEnum = enum_namespace() + + +nochange = IfcChangeActionEnum.NOCHANGE + + +modified = IfcChangeActionEnum.MODIFIED + + +added = IfcChangeActionEnum.ADDED + + +deleted = IfcChangeActionEnum.DELETED + + +notdefined = IfcChangeActionEnum.NOTDEFINED + + +IfcChillerTypeEnum = enum_namespace() + + +aircooled = IfcChillerTypeEnum.AIRCOOLED + + +watercooled = IfcChillerTypeEnum.WATERCOOLED + + +heatrecovery = IfcChillerTypeEnum.HEATRECOVERY + + +userdefined = IfcChillerTypeEnum.USERDEFINED + + +notdefined = IfcChillerTypeEnum.NOTDEFINED + + +IfcChimneyTypeEnum = enum_namespace() + + +userdefined = IfcChimneyTypeEnum.USERDEFINED + + +notdefined = IfcChimneyTypeEnum.NOTDEFINED + + +IfcCoilTypeEnum = enum_namespace() + + +dxcoolingcoil = IfcCoilTypeEnum.DXCOOLINGCOIL + + +electricheatingcoil = IfcCoilTypeEnum.ELECTRICHEATINGCOIL + + +gasheatingcoil = IfcCoilTypeEnum.GASHEATINGCOIL + + +hydroniccoil = IfcCoilTypeEnum.HYDRONICCOIL + + +steamheatingcoil = IfcCoilTypeEnum.STEAMHEATINGCOIL + + +watercoolingcoil = IfcCoilTypeEnum.WATERCOOLINGCOIL + + +waterheatingcoil = IfcCoilTypeEnum.WATERHEATINGCOIL + + +userdefined = IfcCoilTypeEnum.USERDEFINED + + +notdefined = IfcCoilTypeEnum.NOTDEFINED + + +IfcColumnTypeEnum = enum_namespace() + + +column = IfcColumnTypeEnum.COLUMN + + +pilaster = IfcColumnTypeEnum.PILASTER + + +pierstem = IfcColumnTypeEnum.PIERSTEM + + +pierstem_segment = IfcColumnTypeEnum.PIERSTEM_SEGMENT + + +standcolumn = IfcColumnTypeEnum.STANDCOLUMN + + +userdefined = IfcColumnTypeEnum.USERDEFINED + + +notdefined = IfcColumnTypeEnum.NOTDEFINED + + +IfcCommunicationsApplianceTypeEnum = enum_namespace() + + +antenna = IfcCommunicationsApplianceTypeEnum.ANTENNA + + +computer = IfcCommunicationsApplianceTypeEnum.COMPUTER + + +fax = IfcCommunicationsApplianceTypeEnum.FAX + + +gateway = IfcCommunicationsApplianceTypeEnum.GATEWAY + + +modem = IfcCommunicationsApplianceTypeEnum.MODEM + + +networkappliance = IfcCommunicationsApplianceTypeEnum.NETWORKAPPLIANCE + + +networkbridge = IfcCommunicationsApplianceTypeEnum.NETWORKBRIDGE + + +networkhub = IfcCommunicationsApplianceTypeEnum.NETWORKHUB + + +printer = IfcCommunicationsApplianceTypeEnum.PRINTER + + +repeater = IfcCommunicationsApplianceTypeEnum.REPEATER + + +router = IfcCommunicationsApplianceTypeEnum.ROUTER + + +scanner = IfcCommunicationsApplianceTypeEnum.SCANNER + + +automaton = IfcCommunicationsApplianceTypeEnum.AUTOMATON + + +intelligent_peripheral = IfcCommunicationsApplianceTypeEnum.INTELLIGENT_PERIPHERAL + + +ip_network_equipment = IfcCommunicationsApplianceTypeEnum.IP_NETWORK_EQUIPMENT + + +optical_network_unit = IfcCommunicationsApplianceTypeEnum.OPTICAL_NETWORK_UNIT + + +telecommand = IfcCommunicationsApplianceTypeEnum.TELECOMMAND + + +telephonyexchange = IfcCommunicationsApplianceTypeEnum.TELEPHONYEXCHANGE + + +transitioncomponent = IfcCommunicationsApplianceTypeEnum.TRANSITIONCOMPONENT + + +transponder = IfcCommunicationsApplianceTypeEnum.TRANSPONDER + + +transportequipment = IfcCommunicationsApplianceTypeEnum.TRANSPORTEQUIPMENT + + +userdefined = IfcCommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcCommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcComplexPropertyTemplateTypeEnum = enum_namespace() + + +p_complex = IfcComplexPropertyTemplateTypeEnum.P_COMPLEX + + +q_complex = IfcComplexPropertyTemplateTypeEnum.Q_COMPLEX + + +IfcCompressorTypeEnum = enum_namespace() + + +dynamic = IfcCompressorTypeEnum.DYNAMIC + + +reciprocating = IfcCompressorTypeEnum.RECIPROCATING + + +rotary = IfcCompressorTypeEnum.ROTARY + + +scroll = IfcCompressorTypeEnum.SCROLL + + +trochoidal = IfcCompressorTypeEnum.TROCHOIDAL + + +singlestage = IfcCompressorTypeEnum.SINGLESTAGE + + +booster = IfcCompressorTypeEnum.BOOSTER + + +opentype = IfcCompressorTypeEnum.OPENTYPE + + +hermetic = IfcCompressorTypeEnum.HERMETIC + + +semihermetic = IfcCompressorTypeEnum.SEMIHERMETIC + + +weldedshellhermetic = IfcCompressorTypeEnum.WELDEDSHELLHERMETIC + + +rollingpiston = IfcCompressorTypeEnum.ROLLINGPISTON + + +rotaryvane = IfcCompressorTypeEnum.ROTARYVANE + + +singlescrew = IfcCompressorTypeEnum.SINGLESCREW + + +twinscrew = IfcCompressorTypeEnum.TWINSCREW + + +userdefined = IfcCompressorTypeEnum.USERDEFINED + + +notdefined = IfcCompressorTypeEnum.NOTDEFINED + + +IfcCondenserTypeEnum = enum_namespace() + + +aircooled = IfcCondenserTypeEnum.AIRCOOLED + + +evaporativecooled = IfcCondenserTypeEnum.EVAPORATIVECOOLED + + +watercooled = IfcCondenserTypeEnum.WATERCOOLED + + +watercooledbrazedplate = IfcCondenserTypeEnum.WATERCOOLEDBRAZEDPLATE + + +watercooledshellcoil = IfcCondenserTypeEnum.WATERCOOLEDSHELLCOIL + + +watercooledshelltube = IfcCondenserTypeEnum.WATERCOOLEDSHELLTUBE + + +watercooledtubeintube = IfcCondenserTypeEnum.WATERCOOLEDTUBEINTUBE + + +userdefined = IfcCondenserTypeEnum.USERDEFINED + + +notdefined = IfcCondenserTypeEnum.NOTDEFINED + + +IfcConnectionTypeEnum = enum_namespace() + + +atpath = IfcConnectionTypeEnum.ATPATH + + +atstart = IfcConnectionTypeEnum.ATSTART + + +atend = IfcConnectionTypeEnum.ATEND + + +notdefined = IfcConnectionTypeEnum.NOTDEFINED + + +IfcConstraintEnum = enum_namespace() + + +hard = IfcConstraintEnum.HARD + + +soft = IfcConstraintEnum.SOFT + + +advisory = IfcConstraintEnum.ADVISORY + + +userdefined = IfcConstraintEnum.USERDEFINED + + +notdefined = IfcConstraintEnum.NOTDEFINED + + +IfcConstructionEquipmentResourceTypeEnum = enum_namespace() + + +demolishing = IfcConstructionEquipmentResourceTypeEnum.DEMOLISHING + + +earthmoving = IfcConstructionEquipmentResourceTypeEnum.EARTHMOVING + + +erecting = IfcConstructionEquipmentResourceTypeEnum.ERECTING + + +heating = IfcConstructionEquipmentResourceTypeEnum.HEATING + + +lighting = IfcConstructionEquipmentResourceTypeEnum.LIGHTING + + +paving = IfcConstructionEquipmentResourceTypeEnum.PAVING + + +pumping = IfcConstructionEquipmentResourceTypeEnum.PUMPING + + +transporting = IfcConstructionEquipmentResourceTypeEnum.TRANSPORTING + + +userdefined = IfcConstructionEquipmentResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionEquipmentResourceTypeEnum.NOTDEFINED + + +IfcConstructionMaterialResourceTypeEnum = enum_namespace() + + +aggregates = IfcConstructionMaterialResourceTypeEnum.AGGREGATES + + +concrete = IfcConstructionMaterialResourceTypeEnum.CONCRETE + + +drywall = IfcConstructionMaterialResourceTypeEnum.DRYWALL + + +fuel = IfcConstructionMaterialResourceTypeEnum.FUEL + + +gypsum = IfcConstructionMaterialResourceTypeEnum.GYPSUM + + +masonry = IfcConstructionMaterialResourceTypeEnum.MASONRY + + +metal = IfcConstructionMaterialResourceTypeEnum.METAL + + +plastic = IfcConstructionMaterialResourceTypeEnum.PLASTIC + + +wood = IfcConstructionMaterialResourceTypeEnum.WOOD + + +notdefined = IfcConstructionMaterialResourceTypeEnum.NOTDEFINED + + +userdefined = IfcConstructionMaterialResourceTypeEnum.USERDEFINED + + +IfcConstructionProductResourceTypeEnum = enum_namespace() + + +assembly = IfcConstructionProductResourceTypeEnum.ASSEMBLY + + +formwork = IfcConstructionProductResourceTypeEnum.FORMWORK + + +userdefined = IfcConstructionProductResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionProductResourceTypeEnum.NOTDEFINED + + +IfcControllerTypeEnum = enum_namespace() + + +floating = IfcControllerTypeEnum.FLOATING + + +programmable = IfcControllerTypeEnum.PROGRAMMABLE + + +proportional = IfcControllerTypeEnum.PROPORTIONAL + + +multiposition = IfcControllerTypeEnum.MULTIPOSITION + + +twoposition = IfcControllerTypeEnum.TWOPOSITION + + +userdefined = IfcControllerTypeEnum.USERDEFINED + + +notdefined = IfcControllerTypeEnum.NOTDEFINED + + +IfcConveyorSegmentTypeEnum = enum_namespace() + + +chuteconveyor = IfcConveyorSegmentTypeEnum.CHUTECONVEYOR + + +beltconveyor = IfcConveyorSegmentTypeEnum.BELTCONVEYOR + + +screwconveyor = IfcConveyorSegmentTypeEnum.SCREWCONVEYOR + + +bucketconveyor = IfcConveyorSegmentTypeEnum.BUCKETCONVEYOR + + +userdefined = IfcConveyorSegmentTypeEnum.USERDEFINED + + +notdefined = IfcConveyorSegmentTypeEnum.NOTDEFINED + + +IfcCooledBeamTypeEnum = enum_namespace() + + +active = IfcCooledBeamTypeEnum.ACTIVE + + +passive = IfcCooledBeamTypeEnum.PASSIVE + + +userdefined = IfcCooledBeamTypeEnum.USERDEFINED + + +notdefined = IfcCooledBeamTypeEnum.NOTDEFINED + + +IfcCoolingTowerTypeEnum = enum_namespace() + + +naturaldraft = IfcCoolingTowerTypeEnum.NATURALDRAFT + + +mechanicalinduceddraft = IfcCoolingTowerTypeEnum.MECHANICALINDUCEDDRAFT + + +mechanicalforceddraft = IfcCoolingTowerTypeEnum.MECHANICALFORCEDDRAFT + + +userdefined = IfcCoolingTowerTypeEnum.USERDEFINED + + +notdefined = IfcCoolingTowerTypeEnum.NOTDEFINED + + +IfcCostItemTypeEnum = enum_namespace() + + +userdefined = IfcCostItemTypeEnum.USERDEFINED + + +notdefined = IfcCostItemTypeEnum.NOTDEFINED + + +IfcCostScheduleTypeEnum = enum_namespace() + + +budget = IfcCostScheduleTypeEnum.BUDGET + + +costplan = IfcCostScheduleTypeEnum.COSTPLAN + + +estimate = IfcCostScheduleTypeEnum.ESTIMATE + + +tender = IfcCostScheduleTypeEnum.TENDER + + +pricedbillofquantities = IfcCostScheduleTypeEnum.PRICEDBILLOFQUANTITIES + + +unpricedbillofquantities = IfcCostScheduleTypeEnum.UNPRICEDBILLOFQUANTITIES + + +scheduleofrates = IfcCostScheduleTypeEnum.SCHEDULEOFRATES + + +userdefined = IfcCostScheduleTypeEnum.USERDEFINED + + +notdefined = IfcCostScheduleTypeEnum.NOTDEFINED + + +IfcCourseTypeEnum = enum_namespace() + + +armour = IfcCourseTypeEnum.ARMOUR + + +filter = IfcCourseTypeEnum.FILTER + + +ballastbed = IfcCourseTypeEnum.BALLASTBED + + +core = IfcCourseTypeEnum.CORE + + +pavement = IfcCourseTypeEnum.PAVEMENT + + +protection = IfcCourseTypeEnum.PROTECTION + + +userdefined = IfcCourseTypeEnum.USERDEFINED + + +notdefined = IfcCourseTypeEnum.NOTDEFINED + + +IfcCoveringTypeEnum = enum_namespace() + + +ceiling = IfcCoveringTypeEnum.CEILING + + +flooring = IfcCoveringTypeEnum.FLOORING + + +cladding = IfcCoveringTypeEnum.CLADDING + + +roofing = IfcCoveringTypeEnum.ROOFING + + +molding = IfcCoveringTypeEnum.MOLDING + + +skirtingboard = IfcCoveringTypeEnum.SKIRTINGBOARD + + +insulation = IfcCoveringTypeEnum.INSULATION + + +membrane = IfcCoveringTypeEnum.MEMBRANE + + +sleeving = IfcCoveringTypeEnum.SLEEVING + + +wrapping = IfcCoveringTypeEnum.WRAPPING + + +coping = IfcCoveringTypeEnum.COPING + + +userdefined = IfcCoveringTypeEnum.USERDEFINED + + +notdefined = IfcCoveringTypeEnum.NOTDEFINED + + +IfcCrewResourceTypeEnum = enum_namespace() + + +office = IfcCrewResourceTypeEnum.OFFICE + + +site = IfcCrewResourceTypeEnum.SITE + + +userdefined = IfcCrewResourceTypeEnum.USERDEFINED + + +notdefined = IfcCrewResourceTypeEnum.NOTDEFINED + + +IfcCurtainWallTypeEnum = enum_namespace() + + +userdefined = IfcCurtainWallTypeEnum.USERDEFINED + + +notdefined = IfcCurtainWallTypeEnum.NOTDEFINED + + +IfcCurveInterpolationEnum = enum_namespace() + + +linear = IfcCurveInterpolationEnum.LINEAR + + +log_linear = IfcCurveInterpolationEnum.LOG_LINEAR + + +log_log = IfcCurveInterpolationEnum.LOG_LOG + + +notdefined = IfcCurveInterpolationEnum.NOTDEFINED + + +IfcDamperTypeEnum = enum_namespace() + + +backdraftdamper = IfcDamperTypeEnum.BACKDRAFTDAMPER + + +balancingdamper = IfcDamperTypeEnum.BALANCINGDAMPER + + +blastdamper = IfcDamperTypeEnum.BLASTDAMPER + + +controldamper = IfcDamperTypeEnum.CONTROLDAMPER + + +firedamper = IfcDamperTypeEnum.FIREDAMPER + + +firesmokedamper = IfcDamperTypeEnum.FIRESMOKEDAMPER + + +fumehoodexhaust = IfcDamperTypeEnum.FUMEHOODEXHAUST + + +gravitydamper = IfcDamperTypeEnum.GRAVITYDAMPER + + +gravityreliefdamper = IfcDamperTypeEnum.GRAVITYRELIEFDAMPER + + +reliefdamper = IfcDamperTypeEnum.RELIEFDAMPER + + +smokedamper = IfcDamperTypeEnum.SMOKEDAMPER + + +userdefined = IfcDamperTypeEnum.USERDEFINED + + +notdefined = IfcDamperTypeEnum.NOTDEFINED + + +IfcDataOriginEnum = enum_namespace() + + +measured = IfcDataOriginEnum.MEASURED + + +predicted = IfcDataOriginEnum.PREDICTED + + +simulated = IfcDataOriginEnum.SIMULATED + + +userdefined = IfcDataOriginEnum.USERDEFINED + + +notdefined = IfcDataOriginEnum.NOTDEFINED + + +IfcDerivedUnitEnum = enum_namespace() + + +angularvelocityunit = IfcDerivedUnitEnum.ANGULARVELOCITYUNIT + + +areadensityunit = IfcDerivedUnitEnum.AREADENSITYUNIT + + +compoundplaneangleunit = IfcDerivedUnitEnum.COMPOUNDPLANEANGLEUNIT + + +dynamicviscosityunit = IfcDerivedUnitEnum.DYNAMICVISCOSITYUNIT + + +heatfluxdensityunit = IfcDerivedUnitEnum.HEATFLUXDENSITYUNIT + + +integercountrateunit = IfcDerivedUnitEnum.INTEGERCOUNTRATEUNIT + + +isothermalmoisturecapacityunit = IfcDerivedUnitEnum.ISOTHERMALMOISTURECAPACITYUNIT + + +kinematicviscosityunit = IfcDerivedUnitEnum.KINEMATICVISCOSITYUNIT + + +linearvelocityunit = IfcDerivedUnitEnum.LINEARVELOCITYUNIT + + +massdensityunit = IfcDerivedUnitEnum.MASSDENSITYUNIT + + +massflowrateunit = IfcDerivedUnitEnum.MASSFLOWRATEUNIT + + +moisturediffusivityunit = IfcDerivedUnitEnum.MOISTUREDIFFUSIVITYUNIT + + +molecularweightunit = IfcDerivedUnitEnum.MOLECULARWEIGHTUNIT + + +specificheatcapacityunit = IfcDerivedUnitEnum.SPECIFICHEATCAPACITYUNIT + + +thermaladmittanceunit = IfcDerivedUnitEnum.THERMALADMITTANCEUNIT + + +thermalconductanceunit = IfcDerivedUnitEnum.THERMALCONDUCTANCEUNIT + + +thermalresistanceunit = IfcDerivedUnitEnum.THERMALRESISTANCEUNIT + + +thermaltransmittanceunit = IfcDerivedUnitEnum.THERMALTRANSMITTANCEUNIT + + +vaporpermeabilityunit = IfcDerivedUnitEnum.VAPORPERMEABILITYUNIT + + +volumetricflowrateunit = IfcDerivedUnitEnum.VOLUMETRICFLOWRATEUNIT + + +rotationalfrequencyunit = IfcDerivedUnitEnum.ROTATIONALFREQUENCYUNIT + + +torqueunit = IfcDerivedUnitEnum.TORQUEUNIT + + +momentofinertiaunit = IfcDerivedUnitEnum.MOMENTOFINERTIAUNIT + + +linearmomentunit = IfcDerivedUnitEnum.LINEARMOMENTUNIT + + +linearforceunit = IfcDerivedUnitEnum.LINEARFORCEUNIT + + +planarforceunit = IfcDerivedUnitEnum.PLANARFORCEUNIT + + +modulusofelasticityunit = IfcDerivedUnitEnum.MODULUSOFELASTICITYUNIT + + +shearmodulusunit = IfcDerivedUnitEnum.SHEARMODULUSUNIT + + +linearstiffnessunit = IfcDerivedUnitEnum.LINEARSTIFFNESSUNIT + + +rotationalstiffnessunit = IfcDerivedUnitEnum.ROTATIONALSTIFFNESSUNIT + + +modulusofsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFSUBGRADEREACTIONUNIT + + +accelerationunit = IfcDerivedUnitEnum.ACCELERATIONUNIT + + +curvatureunit = IfcDerivedUnitEnum.CURVATUREUNIT + + +heatingvalueunit = IfcDerivedUnitEnum.HEATINGVALUEUNIT + + +ionconcentrationunit = IfcDerivedUnitEnum.IONCONCENTRATIONUNIT + + +luminousintensitydistributionunit = IfcDerivedUnitEnum.LUMINOUSINTENSITYDISTRIBUTIONUNIT + + +massperlengthunit = IfcDerivedUnitEnum.MASSPERLENGTHUNIT + + +modulusoflinearsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFLINEARSUBGRADEREACTIONUNIT + + +modulusofrotationalsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFROTATIONALSUBGRADEREACTIONUNIT + + +phunit = IfcDerivedUnitEnum.PHUNIT + + +rotationalmassunit = IfcDerivedUnitEnum.ROTATIONALMASSUNIT + + +sectionareaintegralunit = IfcDerivedUnitEnum.SECTIONAREAINTEGRALUNIT + + +sectionmodulusunit = IfcDerivedUnitEnum.SECTIONMODULUSUNIT + + +soundpowerlevelunit = IfcDerivedUnitEnum.SOUNDPOWERLEVELUNIT + + +soundpowerunit = IfcDerivedUnitEnum.SOUNDPOWERUNIT + + +soundpressurelevelunit = IfcDerivedUnitEnum.SOUNDPRESSURELEVELUNIT + + +soundpressureunit = IfcDerivedUnitEnum.SOUNDPRESSUREUNIT + + +temperaturegradientunit = IfcDerivedUnitEnum.TEMPERATUREGRADIENTUNIT + + +temperaturerateofchangeunit = IfcDerivedUnitEnum.TEMPERATURERATEOFCHANGEUNIT + + +thermalexpansioncoefficientunit = IfcDerivedUnitEnum.THERMALEXPANSIONCOEFFICIENTUNIT + + +warpingconstantunit = IfcDerivedUnitEnum.WARPINGCONSTANTUNIT + + +warpingmomentunit = IfcDerivedUnitEnum.WARPINGMOMENTUNIT + + +userdefined = IfcDerivedUnitEnum.USERDEFINED + + +IfcDirectionSenseEnum = enum_namespace() + + +positive = IfcDirectionSenseEnum.POSITIVE + + +negative = IfcDirectionSenseEnum.NEGATIVE + + +IfcDiscreteAccessoryTypeEnum = enum_namespace() + + +anchorplate = IfcDiscreteAccessoryTypeEnum.ANCHORPLATE + + +bracket = IfcDiscreteAccessoryTypeEnum.BRACKET + + +shoe = IfcDiscreteAccessoryTypeEnum.SHOE + + +expansion_joint_device = IfcDiscreteAccessoryTypeEnum.EXPANSION_JOINT_DEVICE + + +birdprotection = IfcDiscreteAccessoryTypeEnum.BIRDPROTECTION + + +cablearranger = IfcDiscreteAccessoryTypeEnum.CABLEARRANGER + + +insulator = IfcDiscreteAccessoryTypeEnum.INSULATOR + + +lock = IfcDiscreteAccessoryTypeEnum.LOCK + + +tensioningequipment = IfcDiscreteAccessoryTypeEnum.TENSIONINGEQUIPMENT + + +railpad = IfcDiscreteAccessoryTypeEnum.RAILPAD + + +slidingchair = IfcDiscreteAccessoryTypeEnum.SLIDINGCHAIR + + +panel_strengthening = IfcDiscreteAccessoryTypeEnum.PANEL_STRENGTHENING + + +railbrace = IfcDiscreteAccessoryTypeEnum.RAILBRACE + + +elastic_cushion = IfcDiscreteAccessoryTypeEnum.ELASTIC_CUSHION + + +soundabsorption = IfcDiscreteAccessoryTypeEnum.SOUNDABSORPTION + + +rail_lubrication = IfcDiscreteAccessoryTypeEnum.RAIL_LUBRICATION + + +rail_mechanical_equipment = IfcDiscreteAccessoryTypeEnum.RAIL_MECHANICAL_EQUIPMENT + + +userdefined = IfcDiscreteAccessoryTypeEnum.USERDEFINED + + +notdefined = IfcDiscreteAccessoryTypeEnum.NOTDEFINED + + +IfcDistributionBoardTypeEnum = enum_namespace() + + +switchboard = IfcDistributionBoardTypeEnum.SWITCHBOARD + + +consumerunit = IfcDistributionBoardTypeEnum.CONSUMERUNIT + + +motorcontrolcentre = IfcDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +distributionframe = IfcDistributionBoardTypeEnum.DISTRIBUTIONFRAME + + +distributionboard = IfcDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +userdefined = IfcDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcDistributionBoardTypeEnum.NOTDEFINED + + +IfcDistributionChamberElementTypeEnum = enum_namespace() + + +formedduct = IfcDistributionChamberElementTypeEnum.FORMEDDUCT + + +inspectionchamber = IfcDistributionChamberElementTypeEnum.INSPECTIONCHAMBER + + +inspectionpit = IfcDistributionChamberElementTypeEnum.INSPECTIONPIT + + +manhole = IfcDistributionChamberElementTypeEnum.MANHOLE + + +meterchamber = IfcDistributionChamberElementTypeEnum.METERCHAMBER + + +sump = IfcDistributionChamberElementTypeEnum.SUMP + + +trench = IfcDistributionChamberElementTypeEnum.TRENCH + + +valvechamber = IfcDistributionChamberElementTypeEnum.VALVECHAMBER + + +userdefined = IfcDistributionChamberElementTypeEnum.USERDEFINED + + +notdefined = IfcDistributionChamberElementTypeEnum.NOTDEFINED + + +IfcDistributionPortTypeEnum = enum_namespace() + + +cable = IfcDistributionPortTypeEnum.CABLE + + +cablecarrier = IfcDistributionPortTypeEnum.CABLECARRIER + + +duct = IfcDistributionPortTypeEnum.DUCT + + +pipe = IfcDistributionPortTypeEnum.PIPE + + +wireless = IfcDistributionPortTypeEnum.WIRELESS + + +userdefined = IfcDistributionPortTypeEnum.USERDEFINED + + +notdefined = IfcDistributionPortTypeEnum.NOTDEFINED + + +IfcDistributionSystemEnum = enum_namespace() + + +airconditioning = IfcDistributionSystemEnum.AIRCONDITIONING + + +audiovisual = IfcDistributionSystemEnum.AUDIOVISUAL + + +chemical = IfcDistributionSystemEnum.CHEMICAL + + +chilledwater = IfcDistributionSystemEnum.CHILLEDWATER + + +communication = IfcDistributionSystemEnum.COMMUNICATION + + +compressedair = IfcDistributionSystemEnum.COMPRESSEDAIR + + +condenserwater = IfcDistributionSystemEnum.CONDENSERWATER + + +control = IfcDistributionSystemEnum.CONTROL + + +conveying = IfcDistributionSystemEnum.CONVEYING + + +data = IfcDistributionSystemEnum.DATA + + +disposal = IfcDistributionSystemEnum.DISPOSAL + + +domesticcoldwater = IfcDistributionSystemEnum.DOMESTICCOLDWATER + + +domestichotwater = IfcDistributionSystemEnum.DOMESTICHOTWATER + + +drainage = IfcDistributionSystemEnum.DRAINAGE + + +earthing = IfcDistributionSystemEnum.EARTHING + + +electrical = IfcDistributionSystemEnum.ELECTRICAL + + +electroacoustic = IfcDistributionSystemEnum.ELECTROACOUSTIC + + +exhaust = IfcDistributionSystemEnum.EXHAUST + + +fireprotection = IfcDistributionSystemEnum.FIREPROTECTION + + +fuel = IfcDistributionSystemEnum.FUEL + + +gas = IfcDistributionSystemEnum.GAS + + +hazardous = IfcDistributionSystemEnum.HAZARDOUS + + +heating = IfcDistributionSystemEnum.HEATING + + +lighting = IfcDistributionSystemEnum.LIGHTING + + +lightningprotection = IfcDistributionSystemEnum.LIGHTNINGPROTECTION + + +municipalsolidwaste = IfcDistributionSystemEnum.MUNICIPALSOLIDWASTE + + +oil = IfcDistributionSystemEnum.OIL + + +operational = IfcDistributionSystemEnum.OPERATIONAL + + +powergeneration = IfcDistributionSystemEnum.POWERGENERATION + + +rainwater = IfcDistributionSystemEnum.RAINWATER + + +refrigeration = IfcDistributionSystemEnum.REFRIGERATION + + +security = IfcDistributionSystemEnum.SECURITY + + +sewage = IfcDistributionSystemEnum.SEWAGE + + +signal = IfcDistributionSystemEnum.SIGNAL + + +stormwater = IfcDistributionSystemEnum.STORMWATER + + +telephone = IfcDistributionSystemEnum.TELEPHONE + + +tv = IfcDistributionSystemEnum.TV + + +vacuum = IfcDistributionSystemEnum.VACUUM + + +vent = IfcDistributionSystemEnum.VENT + + +ventilation = IfcDistributionSystemEnum.VENTILATION + + +wastewater = IfcDistributionSystemEnum.WASTEWATER + + +watersupply = IfcDistributionSystemEnum.WATERSUPPLY + + +catenary_system = IfcDistributionSystemEnum.CATENARY_SYSTEM + + +overhead_contactline_system = IfcDistributionSystemEnum.OVERHEAD_CONTACTLINE_SYSTEM + + +return_circuit = IfcDistributionSystemEnum.RETURN_CIRCUIT + + +userdefined = IfcDistributionSystemEnum.USERDEFINED + + +notdefined = IfcDistributionSystemEnum.NOTDEFINED + + +IfcDocumentConfidentialityEnum = enum_namespace() + + +public = IfcDocumentConfidentialityEnum.PUBLIC + + +restricted = IfcDocumentConfidentialityEnum.RESTRICTED + + +confidential = IfcDocumentConfidentialityEnum.CONFIDENTIAL + + +personal = IfcDocumentConfidentialityEnum.PERSONAL + + +userdefined = IfcDocumentConfidentialityEnum.USERDEFINED + + +notdefined = IfcDocumentConfidentialityEnum.NOTDEFINED + + +IfcDocumentStatusEnum = enum_namespace() + + +draft = IfcDocumentStatusEnum.DRAFT + + +finaldraft = IfcDocumentStatusEnum.FINALDRAFT + + +final = IfcDocumentStatusEnum.FINAL + + +revision = IfcDocumentStatusEnum.REVISION + + +notdefined = IfcDocumentStatusEnum.NOTDEFINED + + +IfcDoorPanelOperationEnum = enum_namespace() + + +swinging = IfcDoorPanelOperationEnum.SWINGING + + +double_acting = IfcDoorPanelOperationEnum.DOUBLE_ACTING + + +sliding = IfcDoorPanelOperationEnum.SLIDING + + +folding = IfcDoorPanelOperationEnum.FOLDING + + +revolving = IfcDoorPanelOperationEnum.REVOLVING + + +rollingup = IfcDoorPanelOperationEnum.ROLLINGUP + + +fixedpanel = IfcDoorPanelOperationEnum.FIXEDPANEL + + +userdefined = IfcDoorPanelOperationEnum.USERDEFINED + + +notdefined = IfcDoorPanelOperationEnum.NOTDEFINED + + +IfcDoorPanelPositionEnum = enum_namespace() + + +left = IfcDoorPanelPositionEnum.LEFT + + +middle = IfcDoorPanelPositionEnum.MIDDLE + + +right = IfcDoorPanelPositionEnum.RIGHT + + +notdefined = IfcDoorPanelPositionEnum.NOTDEFINED + + +IfcDoorStyleConstructionEnum = enum_namespace() + + +aluminium = IfcDoorStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcDoorStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcDoorStyleConstructionEnum.STEEL + + +wood = IfcDoorStyleConstructionEnum.WOOD + + +aluminium_wood = IfcDoorStyleConstructionEnum.ALUMINIUM_WOOD + + +aluminium_plastic = IfcDoorStyleConstructionEnum.ALUMINIUM_PLASTIC + + +plastic = IfcDoorStyleConstructionEnum.PLASTIC + + +userdefined = IfcDoorStyleConstructionEnum.USERDEFINED + + +notdefined = IfcDoorStyleConstructionEnum.NOTDEFINED + + +IfcDoorStyleOperationEnum = enum_namespace() + + +single_swing_left = IfcDoorStyleOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorStyleOperationEnum.SINGLE_SWING_RIGHT + + +double_door_single_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_swing_left = IfcDoorStyleOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorStyleOperationEnum.DOUBLE_SWING_RIGHT + + +double_door_double_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +sliding_to_left = IfcDoorStyleOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorStyleOperationEnum.SLIDING_TO_RIGHT + + +double_door_sliding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SLIDING + + +folding_to_left = IfcDoorStyleOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorStyleOperationEnum.FOLDING_TO_RIGHT + + +double_door_folding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_FOLDING + + +revolving = IfcDoorStyleOperationEnum.REVOLVING + + +rollingup = IfcDoorStyleOperationEnum.ROLLINGUP + + +userdefined = IfcDoorStyleOperationEnum.USERDEFINED + + +notdefined = IfcDoorStyleOperationEnum.NOTDEFINED + + +IfcDoorTypeEnum = enum_namespace() + + +door = IfcDoorTypeEnum.DOOR + + +gate = IfcDoorTypeEnum.GATE + + +trapdoor = IfcDoorTypeEnum.TRAPDOOR + + +boom_barrier = IfcDoorTypeEnum.BOOM_BARRIER + + +turnstile = IfcDoorTypeEnum.TURNSTILE + + +userdefined = IfcDoorTypeEnum.USERDEFINED + + +notdefined = IfcDoorTypeEnum.NOTDEFINED + + +IfcDoorTypeOperationEnum = enum_namespace() + + +single_swing_left = IfcDoorTypeOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorTypeOperationEnum.SINGLE_SWING_RIGHT + + +double_door_single_swing = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_swing_left = IfcDoorTypeOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorTypeOperationEnum.DOUBLE_SWING_RIGHT + + +double_door_double_swing = IfcDoorTypeOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +sliding_to_left = IfcDoorTypeOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorTypeOperationEnum.SLIDING_TO_RIGHT + + +double_door_sliding = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SLIDING + + +folding_to_left = IfcDoorTypeOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorTypeOperationEnum.FOLDING_TO_RIGHT + + +double_door_folding = IfcDoorTypeOperationEnum.DOUBLE_DOOR_FOLDING + + +revolving = IfcDoorTypeOperationEnum.REVOLVING + + +rollingup = IfcDoorTypeOperationEnum.ROLLINGUP + + +swing_fixed_left = IfcDoorTypeOperationEnum.SWING_FIXED_LEFT + + +swing_fixed_right = IfcDoorTypeOperationEnum.SWING_FIXED_RIGHT + + +userdefined = IfcDoorTypeOperationEnum.USERDEFINED + + +notdefined = IfcDoorTypeOperationEnum.NOTDEFINED + + +IfcDuctFittingTypeEnum = enum_namespace() + + +bend = IfcDuctFittingTypeEnum.BEND + + +connector = IfcDuctFittingTypeEnum.CONNECTOR + + +entry = IfcDuctFittingTypeEnum.ENTRY + + +exit = IfcDuctFittingTypeEnum.EXIT + + +junction = IfcDuctFittingTypeEnum.JUNCTION + + +obstruction = IfcDuctFittingTypeEnum.OBSTRUCTION + + +transition = IfcDuctFittingTypeEnum.TRANSITION + + +userdefined = IfcDuctFittingTypeEnum.USERDEFINED + + +notdefined = IfcDuctFittingTypeEnum.NOTDEFINED + + +IfcDuctSegmentTypeEnum = enum_namespace() + + +rigidsegment = IfcDuctSegmentTypeEnum.RIGIDSEGMENT + + +flexiblesegment = IfcDuctSegmentTypeEnum.FLEXIBLESEGMENT + + +userdefined = IfcDuctSegmentTypeEnum.USERDEFINED + + +notdefined = IfcDuctSegmentTypeEnum.NOTDEFINED + + +IfcDuctSilencerTypeEnum = enum_namespace() + + +flatoval = IfcDuctSilencerTypeEnum.FLATOVAL + + +rectangular = IfcDuctSilencerTypeEnum.RECTANGULAR + + +round = IfcDuctSilencerTypeEnum.ROUND + + +userdefined = IfcDuctSilencerTypeEnum.USERDEFINED + + +notdefined = IfcDuctSilencerTypeEnum.NOTDEFINED + + +IfcEarthworksCutTypeEnum = enum_namespace() + + +trench = IfcEarthworksCutTypeEnum.TRENCH + + +dredging = IfcEarthworksCutTypeEnum.DREDGING + + +excavation = IfcEarthworksCutTypeEnum.EXCAVATION + + +overexcavation = IfcEarthworksCutTypeEnum.OVEREXCAVATION + + +topsoilremoval = IfcEarthworksCutTypeEnum.TOPSOILREMOVAL + + +stepexcavation = IfcEarthworksCutTypeEnum.STEPEXCAVATION + + +pavementmilling = IfcEarthworksCutTypeEnum.PAVEMENTMILLING + + +cut = IfcEarthworksCutTypeEnum.CUT + + +base_excavation = IfcEarthworksCutTypeEnum.BASE_EXCAVATION + + +userdefined = IfcEarthworksCutTypeEnum.USERDEFINED + + +notdefined = IfcEarthworksCutTypeEnum.NOTDEFINED + + +IfcEarthworksFillTypeEnum = enum_namespace() + + +backfill = IfcEarthworksFillTypeEnum.BACKFILL + + +counterweight = IfcEarthworksFillTypeEnum.COUNTERWEIGHT + + +subgrade = IfcEarthworksFillTypeEnum.SUBGRADE + + +embankment = IfcEarthworksFillTypeEnum.EMBANKMENT + + +transitionsection = IfcEarthworksFillTypeEnum.TRANSITIONSECTION + + +subgradebed = IfcEarthworksFillTypeEnum.SUBGRADEBED + + +slopefill = IfcEarthworksFillTypeEnum.SLOPEFILL + + +userdefined = IfcEarthworksFillTypeEnum.USERDEFINED + + +notdefined = IfcEarthworksFillTypeEnum.NOTDEFINED + + +IfcElectricApplianceTypeEnum = enum_namespace() + + +dishwasher = IfcElectricApplianceTypeEnum.DISHWASHER + + +electriccooker = IfcElectricApplianceTypeEnum.ELECTRICCOOKER + + +freestandingelectricheater = IfcElectricApplianceTypeEnum.FREESTANDINGELECTRICHEATER + + +freestandingfan = IfcElectricApplianceTypeEnum.FREESTANDINGFAN + + +freestandingwaterheater = IfcElectricApplianceTypeEnum.FREESTANDINGWATERHEATER + + +freestandingwatercooler = IfcElectricApplianceTypeEnum.FREESTANDINGWATERCOOLER + + +freezer = IfcElectricApplianceTypeEnum.FREEZER + + +fridge_freezer = IfcElectricApplianceTypeEnum.FRIDGE_FREEZER + + +handdryer = IfcElectricApplianceTypeEnum.HANDDRYER + + +kitchenmachine = IfcElectricApplianceTypeEnum.KITCHENMACHINE + + +microwave = IfcElectricApplianceTypeEnum.MICROWAVE + + +photocopier = IfcElectricApplianceTypeEnum.PHOTOCOPIER + + +refrigerator = IfcElectricApplianceTypeEnum.REFRIGERATOR + + +tumbledryer = IfcElectricApplianceTypeEnum.TUMBLEDRYER + + +vendingmachine = IfcElectricApplianceTypeEnum.VENDINGMACHINE + + +washingmachine = IfcElectricApplianceTypeEnum.WASHINGMACHINE + + +userdefined = IfcElectricApplianceTypeEnum.USERDEFINED + + +notdefined = IfcElectricApplianceTypeEnum.NOTDEFINED + + +IfcElectricDistributionBoardTypeEnum = enum_namespace() + + +consumerunit = IfcElectricDistributionBoardTypeEnum.CONSUMERUNIT + + +distributionboard = IfcElectricDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +motorcontrolcentre = IfcElectricDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +switchboard = IfcElectricDistributionBoardTypeEnum.SWITCHBOARD + + +userdefined = IfcElectricDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcElectricDistributionBoardTypeEnum.NOTDEFINED + + +IfcElectricFlowStorageDeviceTypeEnum = enum_namespace() + + +battery = IfcElectricFlowStorageDeviceTypeEnum.BATTERY + + +capacitorbank = IfcElectricFlowStorageDeviceTypeEnum.CAPACITORBANK + + +harmonicfilter = IfcElectricFlowStorageDeviceTypeEnum.HARMONICFILTER + + +inductorbank = IfcElectricFlowStorageDeviceTypeEnum.INDUCTORBANK + + +ups = IfcElectricFlowStorageDeviceTypeEnum.UPS + + +capacitor = IfcElectricFlowStorageDeviceTypeEnum.CAPACITOR + + +compensator = IfcElectricFlowStorageDeviceTypeEnum.COMPENSATOR + + +inductor = IfcElectricFlowStorageDeviceTypeEnum.INDUCTOR + + +recharger = IfcElectricFlowStorageDeviceTypeEnum.RECHARGER + + +userdefined = IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowStorageDeviceTypeEnum.NOTDEFINED + + +IfcElectricFlowTreatmentDeviceTypeEnum = enum_namespace() + + +electronicfilter = IfcElectricFlowTreatmentDeviceTypeEnum.ELECTRONICFILTER + + +userdefined = IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowTreatmentDeviceTypeEnum.NOTDEFINED + + +IfcElectricGeneratorTypeEnum = enum_namespace() + + +chp = IfcElectricGeneratorTypeEnum.CHP + + +enginegenerator = IfcElectricGeneratorTypeEnum.ENGINEGENERATOR + + +standalone = IfcElectricGeneratorTypeEnum.STANDALONE + + +userdefined = IfcElectricGeneratorTypeEnum.USERDEFINED + + +notdefined = IfcElectricGeneratorTypeEnum.NOTDEFINED + + +IfcElectricMotorTypeEnum = enum_namespace() + + +dc = IfcElectricMotorTypeEnum.DC + + +induction = IfcElectricMotorTypeEnum.INDUCTION + + +polyphase = IfcElectricMotorTypeEnum.POLYPHASE + + +reluctancesynchronous = IfcElectricMotorTypeEnum.RELUCTANCESYNCHRONOUS + + +synchronous = IfcElectricMotorTypeEnum.SYNCHRONOUS + + +userdefined = IfcElectricMotorTypeEnum.USERDEFINED + + +notdefined = IfcElectricMotorTypeEnum.NOTDEFINED + + +IfcElectricTimeControlTypeEnum = enum_namespace() + + +timeclock = IfcElectricTimeControlTypeEnum.TIMECLOCK + + +timedelay = IfcElectricTimeControlTypeEnum.TIMEDELAY + + +relay = IfcElectricTimeControlTypeEnum.RELAY + + +userdefined = IfcElectricTimeControlTypeEnum.USERDEFINED + + +notdefined = IfcElectricTimeControlTypeEnum.NOTDEFINED + + +IfcElementAssemblyTypeEnum = enum_namespace() + + +accessory_assembly = IfcElementAssemblyTypeEnum.ACCESSORY_ASSEMBLY + + +arch = IfcElementAssemblyTypeEnum.ARCH + + +beam_grid = IfcElementAssemblyTypeEnum.BEAM_GRID + + +braced_frame = IfcElementAssemblyTypeEnum.BRACED_FRAME + + +girder = IfcElementAssemblyTypeEnum.GIRDER + + +reinforcement_unit = IfcElementAssemblyTypeEnum.REINFORCEMENT_UNIT + + +rigid_frame = IfcElementAssemblyTypeEnum.RIGID_FRAME + + +slab_field = IfcElementAssemblyTypeEnum.SLAB_FIELD + + +truss = IfcElementAssemblyTypeEnum.TRUSS + + +abutment = IfcElementAssemblyTypeEnum.ABUTMENT + + +pier = IfcElementAssemblyTypeEnum.PIER + + +pylon = IfcElementAssemblyTypeEnum.PYLON + + +cross_bracing = IfcElementAssemblyTypeEnum.CROSS_BRACING + + +deck = IfcElementAssemblyTypeEnum.DECK + + +mast = IfcElementAssemblyTypeEnum.MAST + + +signalassembly = IfcElementAssemblyTypeEnum.SIGNALASSEMBLY + + +grid = IfcElementAssemblyTypeEnum.GRID + + +shelter = IfcElementAssemblyTypeEnum.SHELTER + + +supportingassembly = IfcElementAssemblyTypeEnum.SUPPORTINGASSEMBLY + + +suspensionassembly = IfcElementAssemblyTypeEnum.SUSPENSIONASSEMBLY + + +traction_switching_assembly = IfcElementAssemblyTypeEnum.TRACTION_SWITCHING_ASSEMBLY + + +trackpanel = IfcElementAssemblyTypeEnum.TRACKPANEL + + +turnoutpanel = IfcElementAssemblyTypeEnum.TURNOUTPANEL + + +dilatationpanel = IfcElementAssemblyTypeEnum.DILATATIONPANEL + + +rail_mechanical_equipment_assembly = IfcElementAssemblyTypeEnum.RAIL_MECHANICAL_EQUIPMENT_ASSEMBLY + + +entranceworks = IfcElementAssemblyTypeEnum.ENTRANCEWORKS + + +sumpbuster = IfcElementAssemblyTypeEnum.SUMPBUSTER + + +traffic_calming_device = IfcElementAssemblyTypeEnum.TRAFFIC_CALMING_DEVICE + + +userdefined = IfcElementAssemblyTypeEnum.USERDEFINED + + +notdefined = IfcElementAssemblyTypeEnum.NOTDEFINED + + +IfcElementCompositionEnum = enum_namespace() + + +complex = IfcElementCompositionEnum.COMPLEX + + +element = IfcElementCompositionEnum.ELEMENT + + +partial = IfcElementCompositionEnum.PARTIAL + + +IfcEngineTypeEnum = enum_namespace() + + +externalcombustion = IfcEngineTypeEnum.EXTERNALCOMBUSTION + + +internalcombustion = IfcEngineTypeEnum.INTERNALCOMBUSTION + + +userdefined = IfcEngineTypeEnum.USERDEFINED + + +notdefined = IfcEngineTypeEnum.NOTDEFINED + + +IfcEvaporativeCoolerTypeEnum = enum_namespace() + + +directevaporativerandommediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER + + +directevaporativerigidmediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER + + +directevaporativeslingerspackagedaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER + + +directevaporativepackagedrotaryaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER + + +directevaporativeairwasher = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEAIRWASHER + + +indirectevaporativepackageaircooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEPACKAGEAIRCOOLER + + +indirectevaporativewetcoil = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEWETCOIL + + +indirectevaporativecoolingtowerorcoilcooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER + + +indirectdirectcombination = IfcEvaporativeCoolerTypeEnum.INDIRECTDIRECTCOMBINATION + + +userdefined = IfcEvaporativeCoolerTypeEnum.USERDEFINED + + +notdefined = IfcEvaporativeCoolerTypeEnum.NOTDEFINED + + +IfcEvaporatorTypeEnum = enum_namespace() + + +directexpansion = IfcEvaporatorTypeEnum.DIRECTEXPANSION + + +directexpansionshellandtube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONSHELLANDTUBE + + +directexpansiontubeintube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONTUBEINTUBE + + +directexpansionbrazedplate = IfcEvaporatorTypeEnum.DIRECTEXPANSIONBRAZEDPLATE + + +floodedshellandtube = IfcEvaporatorTypeEnum.FLOODEDSHELLANDTUBE + + +shellandcoil = IfcEvaporatorTypeEnum.SHELLANDCOIL + + +userdefined = IfcEvaporatorTypeEnum.USERDEFINED + + +notdefined = IfcEvaporatorTypeEnum.NOTDEFINED + + +IfcEventTriggerTypeEnum = enum_namespace() + + +eventrule = IfcEventTriggerTypeEnum.EVENTRULE + + +eventmessage = IfcEventTriggerTypeEnum.EVENTMESSAGE + + +eventtime = IfcEventTriggerTypeEnum.EVENTTIME + + +eventcomplex = IfcEventTriggerTypeEnum.EVENTCOMPLEX + + +userdefined = IfcEventTriggerTypeEnum.USERDEFINED + + +notdefined = IfcEventTriggerTypeEnum.NOTDEFINED + + +IfcEventTypeEnum = enum_namespace() + + +startevent = IfcEventTypeEnum.STARTEVENT + + +endevent = IfcEventTypeEnum.ENDEVENT + + +intermediateevent = IfcEventTypeEnum.INTERMEDIATEEVENT + + +userdefined = IfcEventTypeEnum.USERDEFINED + + +notdefined = IfcEventTypeEnum.NOTDEFINED + + +IfcExternalSpatialElementTypeEnum = enum_namespace() + + +external = IfcExternalSpatialElementTypeEnum.EXTERNAL + + +external_earth = IfcExternalSpatialElementTypeEnum.EXTERNAL_EARTH + + +external_water = IfcExternalSpatialElementTypeEnum.EXTERNAL_WATER + + +external_fire = IfcExternalSpatialElementTypeEnum.EXTERNAL_FIRE + + +userdefined = IfcExternalSpatialElementTypeEnum.USERDEFINED + + +notdefined = IfcExternalSpatialElementTypeEnum.NOTDEFINED + + +IfcFacilityPartCommonTypeEnum = enum_namespace() + + +segment = IfcFacilityPartCommonTypeEnum.SEGMENT + + +aboveground = IfcFacilityPartCommonTypeEnum.ABOVEGROUND + + +junction = IfcFacilityPartCommonTypeEnum.JUNCTION + + +levelcrossing = IfcFacilityPartCommonTypeEnum.LEVELCROSSING + + +belowground = IfcFacilityPartCommonTypeEnum.BELOWGROUND + + +substructure = IfcFacilityPartCommonTypeEnum.SUBSTRUCTURE + + +terminal = IfcFacilityPartCommonTypeEnum.TERMINAL + + +superstructure = IfcFacilityPartCommonTypeEnum.SUPERSTRUCTURE + + +userdefined = IfcFacilityPartCommonTypeEnum.USERDEFINED + + +notdefined = IfcFacilityPartCommonTypeEnum.NOTDEFINED + + +IfcFacilityUsageEnum = enum_namespace() + + +lateral = IfcFacilityUsageEnum.LATERAL + + +region = IfcFacilityUsageEnum.REGION + + +vertical = IfcFacilityUsageEnum.VERTICAL + + +longitudinal = IfcFacilityUsageEnum.LONGITUDINAL + + +userdefined = IfcFacilityUsageEnum.USERDEFINED + + +notdefined = IfcFacilityUsageEnum.NOTDEFINED + + +IfcFanTypeEnum = enum_namespace() + + +centrifugalforwardcurved = IfcFanTypeEnum.CENTRIFUGALFORWARDCURVED + + +centrifugalradial = IfcFanTypeEnum.CENTRIFUGALRADIAL + + +centrifugalbackwardinclinedcurved = IfcFanTypeEnum.CENTRIFUGALBACKWARDINCLINEDCURVED + + +centrifugalairfoil = IfcFanTypeEnum.CENTRIFUGALAIRFOIL + + +tubeaxial = IfcFanTypeEnum.TUBEAXIAL + + +vaneaxial = IfcFanTypeEnum.VANEAXIAL + + +propelloraxial = IfcFanTypeEnum.PROPELLORAXIAL + + +userdefined = IfcFanTypeEnum.USERDEFINED + + +notdefined = IfcFanTypeEnum.NOTDEFINED + + +IfcFastenerTypeEnum = enum_namespace() + + +glue = IfcFastenerTypeEnum.GLUE + + +mortar = IfcFastenerTypeEnum.MORTAR + + +weld = IfcFastenerTypeEnum.WELD + + +userdefined = IfcFastenerTypeEnum.USERDEFINED + + +notdefined = IfcFastenerTypeEnum.NOTDEFINED + + +IfcFilterTypeEnum = enum_namespace() + + +airparticlefilter = IfcFilterTypeEnum.AIRPARTICLEFILTER + + +compressedairfilter = IfcFilterTypeEnum.COMPRESSEDAIRFILTER + + +odorfilter = IfcFilterTypeEnum.ODORFILTER + + +oilfilter = IfcFilterTypeEnum.OILFILTER + + +strainer = IfcFilterTypeEnum.STRAINER + + +waterfilter = IfcFilterTypeEnum.WATERFILTER + + +userdefined = IfcFilterTypeEnum.USERDEFINED + + +notdefined = IfcFilterTypeEnum.NOTDEFINED + + +IfcFireSuppressionTerminalTypeEnum = enum_namespace() + + +breechinginlet = IfcFireSuppressionTerminalTypeEnum.BREECHINGINLET + + +firehydrant = IfcFireSuppressionTerminalTypeEnum.FIREHYDRANT + + +hosereel = IfcFireSuppressionTerminalTypeEnum.HOSEREEL + + +sprinkler = IfcFireSuppressionTerminalTypeEnum.SPRINKLER + + +sprinklerdeflector = IfcFireSuppressionTerminalTypeEnum.SPRINKLERDEFLECTOR + + +userdefined = IfcFireSuppressionTerminalTypeEnum.USERDEFINED + + +notdefined = IfcFireSuppressionTerminalTypeEnum.NOTDEFINED + + +IfcFlowDirectionEnum = enum_namespace() + + +source = IfcFlowDirectionEnum.SOURCE + + +sink = IfcFlowDirectionEnum.SINK + + +sourceandsink = IfcFlowDirectionEnum.SOURCEANDSINK + + +notdefined = IfcFlowDirectionEnum.NOTDEFINED + + +IfcFlowInstrumentTypeEnum = enum_namespace() + + +pressuregauge = IfcFlowInstrumentTypeEnum.PRESSUREGAUGE + + +thermometer = IfcFlowInstrumentTypeEnum.THERMOMETER + + +ammeter = IfcFlowInstrumentTypeEnum.AMMETER + + +frequencymeter = IfcFlowInstrumentTypeEnum.FREQUENCYMETER + + +powerfactormeter = IfcFlowInstrumentTypeEnum.POWERFACTORMETER + + +phaseanglemeter = IfcFlowInstrumentTypeEnum.PHASEANGLEMETER + + +voltmeter_peak = IfcFlowInstrumentTypeEnum.VOLTMETER_PEAK + + +voltmeter_rms = IfcFlowInstrumentTypeEnum.VOLTMETER_RMS + + +combined = IfcFlowInstrumentTypeEnum.COMBINED + + +voltmeter = IfcFlowInstrumentTypeEnum.VOLTMETER + + +userdefined = IfcFlowInstrumentTypeEnum.USERDEFINED + + +notdefined = IfcFlowInstrumentTypeEnum.NOTDEFINED + + +IfcFlowMeterTypeEnum = enum_namespace() + + +energymeter = IfcFlowMeterTypeEnum.ENERGYMETER + + +gasmeter = IfcFlowMeterTypeEnum.GASMETER + + +oilmeter = IfcFlowMeterTypeEnum.OILMETER + + +watermeter = IfcFlowMeterTypeEnum.WATERMETER + + +userdefined = IfcFlowMeterTypeEnum.USERDEFINED + + +notdefined = IfcFlowMeterTypeEnum.NOTDEFINED + + +IfcFootingTypeEnum = enum_namespace() + + +caisson_foundation = IfcFootingTypeEnum.CAISSON_FOUNDATION + + +footing_beam = IfcFootingTypeEnum.FOOTING_BEAM + + +pad_footing = IfcFootingTypeEnum.PAD_FOOTING + + +pile_cap = IfcFootingTypeEnum.PILE_CAP + + +strip_footing = IfcFootingTypeEnum.STRIP_FOOTING + + +userdefined = IfcFootingTypeEnum.USERDEFINED + + +notdefined = IfcFootingTypeEnum.NOTDEFINED + + +IfcFurnitureTypeEnum = enum_namespace() + + +chair = IfcFurnitureTypeEnum.CHAIR + + +table = IfcFurnitureTypeEnum.TABLE + + +desk = IfcFurnitureTypeEnum.DESK + + +bed = IfcFurnitureTypeEnum.BED + + +filecabinet = IfcFurnitureTypeEnum.FILECABINET + + +shelf = IfcFurnitureTypeEnum.SHELF + + +sofa = IfcFurnitureTypeEnum.SOFA + + +technicalcabinet = IfcFurnitureTypeEnum.TECHNICALCABINET + + +userdefined = IfcFurnitureTypeEnum.USERDEFINED + + +notdefined = IfcFurnitureTypeEnum.NOTDEFINED + + +IfcGeographicElementTypeEnum = enum_namespace() + + +terrain = IfcGeographicElementTypeEnum.TERRAIN + + +soil_boring_point = IfcGeographicElementTypeEnum.SOIL_BORING_POINT + + +userdefined = IfcGeographicElementTypeEnum.USERDEFINED + + +notdefined = IfcGeographicElementTypeEnum.NOTDEFINED + + +IfcGeometricProjectionEnum = enum_namespace() + + +graph_view = IfcGeometricProjectionEnum.GRAPH_VIEW + + +sketch_view = IfcGeometricProjectionEnum.SKETCH_VIEW + + +model_view = IfcGeometricProjectionEnum.MODEL_VIEW + + +plan_view = IfcGeometricProjectionEnum.PLAN_VIEW + + +reflected_plan_view = IfcGeometricProjectionEnum.REFLECTED_PLAN_VIEW + + +section_view = IfcGeometricProjectionEnum.SECTION_VIEW + + +elevation_view = IfcGeometricProjectionEnum.ELEVATION_VIEW + + +userdefined = IfcGeometricProjectionEnum.USERDEFINED + + +notdefined = IfcGeometricProjectionEnum.NOTDEFINED + + +IfcGlobalOrLocalEnum = enum_namespace() + + +global_coords = IfcGlobalOrLocalEnum.GLOBAL_COORDS + + +local_coords = IfcGlobalOrLocalEnum.LOCAL_COORDS + + +IfcGridTypeEnum = enum_namespace() + + +rectangular = IfcGridTypeEnum.RECTANGULAR + + +radial = IfcGridTypeEnum.RADIAL + + +triangular = IfcGridTypeEnum.TRIANGULAR + + +irregular = IfcGridTypeEnum.IRREGULAR + + +userdefined = IfcGridTypeEnum.USERDEFINED + + +notdefined = IfcGridTypeEnum.NOTDEFINED + + +IfcHeatExchangerTypeEnum = enum_namespace() + + +plate = IfcHeatExchangerTypeEnum.PLATE + + +shellandtube = IfcHeatExchangerTypeEnum.SHELLANDTUBE + + +turnoutheating = IfcHeatExchangerTypeEnum.TURNOUTHEATING + + +userdefined = IfcHeatExchangerTypeEnum.USERDEFINED + + +notdefined = IfcHeatExchangerTypeEnum.NOTDEFINED + + +IfcHumidifierTypeEnum = enum_namespace() + + +steaminjection = IfcHumidifierTypeEnum.STEAMINJECTION + + +adiabaticairwasher = IfcHumidifierTypeEnum.ADIABATICAIRWASHER + + +adiabaticpan = IfcHumidifierTypeEnum.ADIABATICPAN + + +adiabaticwettedelement = IfcHumidifierTypeEnum.ADIABATICWETTEDELEMENT + + +adiabaticatomizing = IfcHumidifierTypeEnum.ADIABATICATOMIZING + + +adiabaticultrasonic = IfcHumidifierTypeEnum.ADIABATICULTRASONIC + + +adiabaticrigidmedia = IfcHumidifierTypeEnum.ADIABATICRIGIDMEDIA + + +adiabaticcompressedairnozzle = IfcHumidifierTypeEnum.ADIABATICCOMPRESSEDAIRNOZZLE + + +assistedelectric = IfcHumidifierTypeEnum.ASSISTEDELECTRIC + + +assistednaturalgas = IfcHumidifierTypeEnum.ASSISTEDNATURALGAS + + +assistedpropane = IfcHumidifierTypeEnum.ASSISTEDPROPANE + + +assistedbutane = IfcHumidifierTypeEnum.ASSISTEDBUTANE + + +assistedsteam = IfcHumidifierTypeEnum.ASSISTEDSTEAM + + +userdefined = IfcHumidifierTypeEnum.USERDEFINED + + +notdefined = IfcHumidifierTypeEnum.NOTDEFINED + + +IfcImpactProtectionDeviceTypeEnum = enum_namespace() + + +crashcushion = IfcImpactProtectionDeviceTypeEnum.CRASHCUSHION + + +dampingsystem = IfcImpactProtectionDeviceTypeEnum.DAMPINGSYSTEM + + +fender = IfcImpactProtectionDeviceTypeEnum.FENDER + + +bumper = IfcImpactProtectionDeviceTypeEnum.BUMPER + + +userdefined = IfcImpactProtectionDeviceTypeEnum.USERDEFINED + + +notdefined = IfcImpactProtectionDeviceTypeEnum.NOTDEFINED + + +IfcInterceptorTypeEnum = enum_namespace() + + +cyclonic = IfcInterceptorTypeEnum.CYCLONIC + + +grease = IfcInterceptorTypeEnum.GREASE + + +oil = IfcInterceptorTypeEnum.OIL + + +petrol = IfcInterceptorTypeEnum.PETROL + + +userdefined = IfcInterceptorTypeEnum.USERDEFINED + + +notdefined = IfcInterceptorTypeEnum.NOTDEFINED + + +IfcInternalOrExternalEnum = enum_namespace() + + +internal = IfcInternalOrExternalEnum.INTERNAL + + +external = IfcInternalOrExternalEnum.EXTERNAL + + +external_earth = IfcInternalOrExternalEnum.EXTERNAL_EARTH + + +external_water = IfcInternalOrExternalEnum.EXTERNAL_WATER + + +external_fire = IfcInternalOrExternalEnum.EXTERNAL_FIRE + + +notdefined = IfcInternalOrExternalEnum.NOTDEFINED + + +IfcInventoryTypeEnum = enum_namespace() + + +assetinventory = IfcInventoryTypeEnum.ASSETINVENTORY + + +spaceinventory = IfcInventoryTypeEnum.SPACEINVENTORY + + +furnitureinventory = IfcInventoryTypeEnum.FURNITUREINVENTORY + + +userdefined = IfcInventoryTypeEnum.USERDEFINED + + +notdefined = IfcInventoryTypeEnum.NOTDEFINED + + +IfcJunctionBoxTypeEnum = enum_namespace() + + +data = IfcJunctionBoxTypeEnum.DATA + + +power = IfcJunctionBoxTypeEnum.POWER + + +userdefined = IfcJunctionBoxTypeEnum.USERDEFINED + + +notdefined = IfcJunctionBoxTypeEnum.NOTDEFINED + + +IfcKnotType = enum_namespace() + + +uniform_knots = IfcKnotType.UNIFORM_KNOTS + + +quasi_uniform_knots = IfcKnotType.QUASI_UNIFORM_KNOTS + + +piecewise_bezier_knots = IfcKnotType.PIECEWISE_BEZIER_KNOTS + + +unspecified = IfcKnotType.UNSPECIFIED + + +IfcLaborResourceTypeEnum = enum_namespace() + + +administration = IfcLaborResourceTypeEnum.ADMINISTRATION + + +carpentry = IfcLaborResourceTypeEnum.CARPENTRY + + +cleaning = IfcLaborResourceTypeEnum.CLEANING + + +concrete = IfcLaborResourceTypeEnum.CONCRETE + + +drywall = IfcLaborResourceTypeEnum.DRYWALL + + +electric = IfcLaborResourceTypeEnum.ELECTRIC + + +finishing = IfcLaborResourceTypeEnum.FINISHING + + +flooring = IfcLaborResourceTypeEnum.FLOORING + + +general = IfcLaborResourceTypeEnum.GENERAL + + +hvac = IfcLaborResourceTypeEnum.HVAC + + +landscaping = IfcLaborResourceTypeEnum.LANDSCAPING + + +masonry = IfcLaborResourceTypeEnum.MASONRY + + +painting = IfcLaborResourceTypeEnum.PAINTING + + +paving = IfcLaborResourceTypeEnum.PAVING + + +plumbing = IfcLaborResourceTypeEnum.PLUMBING + + +roofing = IfcLaborResourceTypeEnum.ROOFING + + +sitegrading = IfcLaborResourceTypeEnum.SITEGRADING + + +steelwork = IfcLaborResourceTypeEnum.STEELWORK + + +surveying = IfcLaborResourceTypeEnum.SURVEYING + + +userdefined = IfcLaborResourceTypeEnum.USERDEFINED + + +notdefined = IfcLaborResourceTypeEnum.NOTDEFINED + + +IfcLampTypeEnum = enum_namespace() + + +compactfluorescent = IfcLampTypeEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLampTypeEnum.FLUORESCENT + + +halogen = IfcLampTypeEnum.HALOGEN + + +highpressuremercury = IfcLampTypeEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLampTypeEnum.HIGHPRESSURESODIUM + + +led = IfcLampTypeEnum.LED + + +metalhalide = IfcLampTypeEnum.METALHALIDE + + +oled = IfcLampTypeEnum.OLED + + +tungstenfilament = IfcLampTypeEnum.TUNGSTENFILAMENT + + +userdefined = IfcLampTypeEnum.USERDEFINED + + +notdefined = IfcLampTypeEnum.NOTDEFINED + + +IfcLayerSetDirectionEnum = enum_namespace() + + +axis1 = IfcLayerSetDirectionEnum.AXIS1 + + +axis2 = IfcLayerSetDirectionEnum.AXIS2 + + +axis3 = IfcLayerSetDirectionEnum.AXIS3 + + +IfcLightDistributionCurveEnum = enum_namespace() + + +type_a = IfcLightDistributionCurveEnum.TYPE_A + + +type_b = IfcLightDistributionCurveEnum.TYPE_B + + +type_c = IfcLightDistributionCurveEnum.TYPE_C + + +notdefined = IfcLightDistributionCurveEnum.NOTDEFINED + + +IfcLightEmissionSourceEnum = enum_namespace() + + +compactfluorescent = IfcLightEmissionSourceEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLightEmissionSourceEnum.FLUORESCENT + + +highpressuremercury = IfcLightEmissionSourceEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLightEmissionSourceEnum.HIGHPRESSURESODIUM + + +lightemittingdiode = IfcLightEmissionSourceEnum.LIGHTEMITTINGDIODE + + +lowpressuresodium = IfcLightEmissionSourceEnum.LOWPRESSURESODIUM + + +lowvoltagehalogen = IfcLightEmissionSourceEnum.LOWVOLTAGEHALOGEN + + +mainvoltagehalogen = IfcLightEmissionSourceEnum.MAINVOLTAGEHALOGEN + + +metalhalide = IfcLightEmissionSourceEnum.METALHALIDE + + +tungstenfilament = IfcLightEmissionSourceEnum.TUNGSTENFILAMENT + + +notdefined = IfcLightEmissionSourceEnum.NOTDEFINED + + +IfcLightFixtureTypeEnum = enum_namespace() + + +pointsource = IfcLightFixtureTypeEnum.POINTSOURCE + + +directionsource = IfcLightFixtureTypeEnum.DIRECTIONSOURCE + + +securitylighting = IfcLightFixtureTypeEnum.SECURITYLIGHTING + + +userdefined = IfcLightFixtureTypeEnum.USERDEFINED + + +notdefined = IfcLightFixtureTypeEnum.NOTDEFINED + + +IfcLiquidTerminalTypeEnum = enum_namespace() + + +loadingarm = IfcLiquidTerminalTypeEnum.LOADINGARM + + +hosereel = IfcLiquidTerminalTypeEnum.HOSEREEL + + +userdefined = IfcLiquidTerminalTypeEnum.USERDEFINED + + +notdefined = IfcLiquidTerminalTypeEnum.NOTDEFINED + + +IfcLoadGroupTypeEnum = enum_namespace() + + +load_group = IfcLoadGroupTypeEnum.LOAD_GROUP + + +load_case = IfcLoadGroupTypeEnum.LOAD_CASE + + +load_combination = IfcLoadGroupTypeEnum.LOAD_COMBINATION + + +userdefined = IfcLoadGroupTypeEnum.USERDEFINED + + +notdefined = IfcLoadGroupTypeEnum.NOTDEFINED + + +IfcLogicalOperatorEnum = enum_namespace() + + +logicaland = IfcLogicalOperatorEnum.LOGICALAND + + +logicalor = IfcLogicalOperatorEnum.LOGICALOR + + +logicalxor = IfcLogicalOperatorEnum.LOGICALXOR + + +logicalnotand = IfcLogicalOperatorEnum.LOGICALNOTAND + + +logicalnotor = IfcLogicalOperatorEnum.LOGICALNOTOR + + +IfcMarineFacilityTypeEnum = enum_namespace() + + +canal = IfcMarineFacilityTypeEnum.CANAL + + +waterwayshiplift = IfcMarineFacilityTypeEnum.WATERWAYSHIPLIFT + + +embankment = IfcMarineFacilityTypeEnum.EMBANKMENT + + +launchrecovery = IfcMarineFacilityTypeEnum.LAUNCHRECOVERY + + +marinedefence = IfcMarineFacilityTypeEnum.MARINEDEFENCE + + +hydrolift = IfcMarineFacilityTypeEnum.HYDROLIFT + + +shipyard = IfcMarineFacilityTypeEnum.SHIPYARD + + +shiplift = IfcMarineFacilityTypeEnum.SHIPLIFT + + +port = IfcMarineFacilityTypeEnum.PORT + + +quay = IfcMarineFacilityTypeEnum.QUAY + + +floatingdock = IfcMarineFacilityTypeEnum.FLOATINGDOCK + + +navigationalchannel = IfcMarineFacilityTypeEnum.NAVIGATIONALCHANNEL + + +breakwater = IfcMarineFacilityTypeEnum.BREAKWATER + + +drydock = IfcMarineFacilityTypeEnum.DRYDOCK + + +jetty = IfcMarineFacilityTypeEnum.JETTY + + +shiplock = IfcMarineFacilityTypeEnum.SHIPLOCK + + +barrierbeach = IfcMarineFacilityTypeEnum.BARRIERBEACH + + +slipway = IfcMarineFacilityTypeEnum.SLIPWAY + + +waterway = IfcMarineFacilityTypeEnum.WATERWAY + + +userdefined = IfcMarineFacilityTypeEnum.USERDEFINED + + +notdefined = IfcMarineFacilityTypeEnum.NOTDEFINED + + +IfcMarinePartTypeEnum = enum_namespace() + + +crest = IfcMarinePartTypeEnum.CREST + + +manufacturing = IfcMarinePartTypeEnum.MANUFACTURING + + +lowwaterline = IfcMarinePartTypeEnum.LOWWATERLINE + + +core = IfcMarinePartTypeEnum.CORE + + +waterfield = IfcMarinePartTypeEnum.WATERFIELD + + +cill_level = IfcMarinePartTypeEnum.CILL_LEVEL + + +berthingstructure = IfcMarinePartTypeEnum.BERTHINGSTRUCTURE + + +copelevel = IfcMarinePartTypeEnum.COPELEVEL + + +chamber = IfcMarinePartTypeEnum.CHAMBER + + +storage = IfcMarinePartTypeEnum.STORAGE + + +approachchannel = IfcMarinePartTypeEnum.APPROACHCHANNEL + + +vehicleservicing = IfcMarinePartTypeEnum.VEHICLESERVICING + + +shiptransfer = IfcMarinePartTypeEnum.SHIPTRANSFER + + +gatehead = IfcMarinePartTypeEnum.GATEHEAD + + +gudingstructure = IfcMarinePartTypeEnum.GUDINGSTRUCTURE + + +belowwaterline = IfcMarinePartTypeEnum.BELOWWATERLINE + + +weatherside = IfcMarinePartTypeEnum.WEATHERSIDE + + +landfield = IfcMarinePartTypeEnum.LANDFIELD + + +protection = IfcMarinePartTypeEnum.PROTECTION + + +leewardside = IfcMarinePartTypeEnum.LEEWARDSIDE + + +abovewaterline = IfcMarinePartTypeEnum.ABOVEWATERLINE + + +anchorage = IfcMarinePartTypeEnum.ANCHORAGE + + +navigationalarea = IfcMarinePartTypeEnum.NAVIGATIONALAREA + + +highwaterline = IfcMarinePartTypeEnum.HIGHWATERLINE + + +userdefined = IfcMarinePartTypeEnum.USERDEFINED + + +notdefined = IfcMarinePartTypeEnum.NOTDEFINED + + +IfcMechanicalFastenerTypeEnum = enum_namespace() + + +anchorbolt = IfcMechanicalFastenerTypeEnum.ANCHORBOLT + + +bolt = IfcMechanicalFastenerTypeEnum.BOLT + + +dowel = IfcMechanicalFastenerTypeEnum.DOWEL + + +nail = IfcMechanicalFastenerTypeEnum.NAIL + + +nailplate = IfcMechanicalFastenerTypeEnum.NAILPLATE + + +rivet = IfcMechanicalFastenerTypeEnum.RIVET + + +screw = IfcMechanicalFastenerTypeEnum.SCREW + + +shearconnector = IfcMechanicalFastenerTypeEnum.SHEARCONNECTOR + + +staple = IfcMechanicalFastenerTypeEnum.STAPLE + + +studshearconnector = IfcMechanicalFastenerTypeEnum.STUDSHEARCONNECTOR + + +coupler = IfcMechanicalFastenerTypeEnum.COUPLER + + +railjoint = IfcMechanicalFastenerTypeEnum.RAILJOINT + + +railfastening = IfcMechanicalFastenerTypeEnum.RAILFASTENING + + +chain = IfcMechanicalFastenerTypeEnum.CHAIN + + +rope = IfcMechanicalFastenerTypeEnum.ROPE + + +userdefined = IfcMechanicalFastenerTypeEnum.USERDEFINED + + +notdefined = IfcMechanicalFastenerTypeEnum.NOTDEFINED + + +IfcMedicalDeviceTypeEnum = enum_namespace() + + +airstation = IfcMedicalDeviceTypeEnum.AIRSTATION + + +feedairunit = IfcMedicalDeviceTypeEnum.FEEDAIRUNIT + + +oxygengenerator = IfcMedicalDeviceTypeEnum.OXYGENGENERATOR + + +oxygenplant = IfcMedicalDeviceTypeEnum.OXYGENPLANT + + +vacuumstation = IfcMedicalDeviceTypeEnum.VACUUMSTATION + + +userdefined = IfcMedicalDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMedicalDeviceTypeEnum.NOTDEFINED + + +IfcMemberTypeEnum = enum_namespace() + + +brace = IfcMemberTypeEnum.BRACE + + +chord = IfcMemberTypeEnum.CHORD + + +collar = IfcMemberTypeEnum.COLLAR + + +member = IfcMemberTypeEnum.MEMBER + + +mullion = IfcMemberTypeEnum.MULLION + + +plate = IfcMemberTypeEnum.PLATE + + +post = IfcMemberTypeEnum.POST + + +purlin = IfcMemberTypeEnum.PURLIN + + +rafter = IfcMemberTypeEnum.RAFTER + + +stringer = IfcMemberTypeEnum.STRINGER + + +strut = IfcMemberTypeEnum.STRUT + + +stud = IfcMemberTypeEnum.STUD + + +stiffening_rib = IfcMemberTypeEnum.STIFFENING_RIB + + +arch_segment = IfcMemberTypeEnum.ARCH_SEGMENT + + +suspension_cable = IfcMemberTypeEnum.SUSPENSION_CABLE + + +suspender = IfcMemberTypeEnum.SUSPENDER + + +stay_cable = IfcMemberTypeEnum.STAY_CABLE + + +structuralcable = IfcMemberTypeEnum.STRUCTURALCABLE + + +tiebar = IfcMemberTypeEnum.TIEBAR + + +userdefined = IfcMemberTypeEnum.USERDEFINED + + +notdefined = IfcMemberTypeEnum.NOTDEFINED + + +IfcMobileTelecommunicationsApplianceTypeEnum = enum_namespace() + + +e_utran_node_b = IfcMobileTelecommunicationsApplianceTypeEnum.E_UTRAN_NODE_B + + +remote_radio_unit = IfcMobileTelecommunicationsApplianceTypeEnum.REMOTE_RADIO_UNIT + + +accesspoint = IfcMobileTelecommunicationsApplianceTypeEnum.ACCESSPOINT + + +basetransceiverstation = IfcMobileTelecommunicationsApplianceTypeEnum.BASETRANSCEIVERSTATION + + +remoteunit = IfcMobileTelecommunicationsApplianceTypeEnum.REMOTEUNIT + + +basebandunit = IfcMobileTelecommunicationsApplianceTypeEnum.BASEBANDUNIT + + +masterunit = IfcMobileTelecommunicationsApplianceTypeEnum.MASTERUNIT + + +userdefined = IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcMobileTelecommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcMooringDeviceTypeEnum = enum_namespace() + + +linetensioner = IfcMooringDeviceTypeEnum.LINETENSIONER + + +magneticdevice = IfcMooringDeviceTypeEnum.MAGNETICDEVICE + + +mooringhooks = IfcMooringDeviceTypeEnum.MOORINGHOOKS + + +vacuumdevice = IfcMooringDeviceTypeEnum.VACUUMDEVICE + + +bollard = IfcMooringDeviceTypeEnum.BOLLARD + + +userdefined = IfcMooringDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMooringDeviceTypeEnum.NOTDEFINED + + +IfcMotorConnectionTypeEnum = enum_namespace() + + +beltdrive = IfcMotorConnectionTypeEnum.BELTDRIVE + + +coupling = IfcMotorConnectionTypeEnum.COUPLING + + +directdrive = IfcMotorConnectionTypeEnum.DIRECTDRIVE + + +userdefined = IfcMotorConnectionTypeEnum.USERDEFINED + + +notdefined = IfcMotorConnectionTypeEnum.NOTDEFINED + + +IfcNavigationElementTypeEnum = enum_namespace() + + +beacon = IfcNavigationElementTypeEnum.BEACON + + +buoy = IfcNavigationElementTypeEnum.BUOY + + +userdefined = IfcNavigationElementTypeEnum.USERDEFINED + + +notdefined = IfcNavigationElementTypeEnum.NOTDEFINED + + +IfcNullStyle = enum_namespace() + + +null = IfcNullStyle.NULL + + +IfcObjectTypeEnum = enum_namespace() + + +product = IfcObjectTypeEnum.PRODUCT + + +process = IfcObjectTypeEnum.PROCESS + + +control = IfcObjectTypeEnum.CONTROL + + +resource = IfcObjectTypeEnum.RESOURCE + + +actor = IfcObjectTypeEnum.ACTOR + + +group = IfcObjectTypeEnum.GROUP + + +project = IfcObjectTypeEnum.PROJECT + + +notdefined = IfcObjectTypeEnum.NOTDEFINED + + +IfcObjectiveEnum = enum_namespace() + + +codecompliance = IfcObjectiveEnum.CODECOMPLIANCE + + +codewaiver = IfcObjectiveEnum.CODEWAIVER + + +designintent = IfcObjectiveEnum.DESIGNINTENT + + +external = IfcObjectiveEnum.EXTERNAL + + +healthandsafety = IfcObjectiveEnum.HEALTHANDSAFETY + + +mergeconflict = IfcObjectiveEnum.MERGECONFLICT + + +modelview = IfcObjectiveEnum.MODELVIEW + + +parameter = IfcObjectiveEnum.PARAMETER + + +requirement = IfcObjectiveEnum.REQUIREMENT + + +specification = IfcObjectiveEnum.SPECIFICATION + + +triggercondition = IfcObjectiveEnum.TRIGGERCONDITION + + +userdefined = IfcObjectiveEnum.USERDEFINED + + +notdefined = IfcObjectiveEnum.NOTDEFINED + + +IfcOccupantTypeEnum = enum_namespace() + + +assignee = IfcOccupantTypeEnum.ASSIGNEE + + +assignor = IfcOccupantTypeEnum.ASSIGNOR + + +lessee = IfcOccupantTypeEnum.LESSEE + + +lessor = IfcOccupantTypeEnum.LESSOR + + +lettingagent = IfcOccupantTypeEnum.LETTINGAGENT + + +owner = IfcOccupantTypeEnum.OWNER + + +tenant = IfcOccupantTypeEnum.TENANT + + +userdefined = IfcOccupantTypeEnum.USERDEFINED + + +notdefined = IfcOccupantTypeEnum.NOTDEFINED + + +IfcOpeningElementTypeEnum = enum_namespace() + + +opening = IfcOpeningElementTypeEnum.OPENING + + +recess = IfcOpeningElementTypeEnum.RECESS + + +userdefined = IfcOpeningElementTypeEnum.USERDEFINED + + +notdefined = IfcOpeningElementTypeEnum.NOTDEFINED + + +IfcOutletTypeEnum = enum_namespace() + + +audiovisualoutlet = IfcOutletTypeEnum.AUDIOVISUALOUTLET + + +communicationsoutlet = IfcOutletTypeEnum.COMMUNICATIONSOUTLET + + +poweroutlet = IfcOutletTypeEnum.POWEROUTLET + + +dataoutlet = IfcOutletTypeEnum.DATAOUTLET + + +telephoneoutlet = IfcOutletTypeEnum.TELEPHONEOUTLET + + +userdefined = IfcOutletTypeEnum.USERDEFINED + + +notdefined = IfcOutletTypeEnum.NOTDEFINED + + +IfcPerformanceHistoryTypeEnum = enum_namespace() + + +userdefined = IfcPerformanceHistoryTypeEnum.USERDEFINED + + +notdefined = IfcPerformanceHistoryTypeEnum.NOTDEFINED + + +IfcPermeableCoveringOperationEnum = enum_namespace() + + +grill = IfcPermeableCoveringOperationEnum.GRILL + + +louver = IfcPermeableCoveringOperationEnum.LOUVER + + +screen = IfcPermeableCoveringOperationEnum.SCREEN + + +userdefined = IfcPermeableCoveringOperationEnum.USERDEFINED + + +notdefined = IfcPermeableCoveringOperationEnum.NOTDEFINED + + +IfcPermitTypeEnum = enum_namespace() + + +access = IfcPermitTypeEnum.ACCESS + + +building = IfcPermitTypeEnum.BUILDING + + +work = IfcPermitTypeEnum.WORK + + +userdefined = IfcPermitTypeEnum.USERDEFINED + + +notdefined = IfcPermitTypeEnum.NOTDEFINED + + +IfcPhysicalOrVirtualEnum = enum_namespace() + + +physical = IfcPhysicalOrVirtualEnum.PHYSICAL + + +virtual = IfcPhysicalOrVirtualEnum.VIRTUAL + + +notdefined = IfcPhysicalOrVirtualEnum.NOTDEFINED + + +IfcPileConstructionEnum = enum_namespace() + + +cast_in_place = IfcPileConstructionEnum.CAST_IN_PLACE + + +composite = IfcPileConstructionEnum.COMPOSITE + + +precast_concrete = IfcPileConstructionEnum.PRECAST_CONCRETE + + +prefab_steel = IfcPileConstructionEnum.PREFAB_STEEL + + +userdefined = IfcPileConstructionEnum.USERDEFINED + + +notdefined = IfcPileConstructionEnum.NOTDEFINED + + +IfcPileTypeEnum = enum_namespace() + + +bored = IfcPileTypeEnum.BORED + + +driven = IfcPileTypeEnum.DRIVEN + + +jetgrouting = IfcPileTypeEnum.JETGROUTING + + +cohesion = IfcPileTypeEnum.COHESION + + +friction = IfcPileTypeEnum.FRICTION + + +support = IfcPileTypeEnum.SUPPORT + + +userdefined = IfcPileTypeEnum.USERDEFINED + + +notdefined = IfcPileTypeEnum.NOTDEFINED + + +IfcPipeFittingTypeEnum = enum_namespace() + + +bend = IfcPipeFittingTypeEnum.BEND + + +connector = IfcPipeFittingTypeEnum.CONNECTOR + + +entry = IfcPipeFittingTypeEnum.ENTRY + + +exit = IfcPipeFittingTypeEnum.EXIT + + +junction = IfcPipeFittingTypeEnum.JUNCTION + + +obstruction = IfcPipeFittingTypeEnum.OBSTRUCTION + + +transition = IfcPipeFittingTypeEnum.TRANSITION + + +userdefined = IfcPipeFittingTypeEnum.USERDEFINED + + +notdefined = IfcPipeFittingTypeEnum.NOTDEFINED + + +IfcPipeSegmentTypeEnum = enum_namespace() + + +culvert = IfcPipeSegmentTypeEnum.CULVERT + + +flexiblesegment = IfcPipeSegmentTypeEnum.FLEXIBLESEGMENT + + +rigidsegment = IfcPipeSegmentTypeEnum.RIGIDSEGMENT + + +gutter = IfcPipeSegmentTypeEnum.GUTTER + + +spool = IfcPipeSegmentTypeEnum.SPOOL + + +userdefined = IfcPipeSegmentTypeEnum.USERDEFINED + + +notdefined = IfcPipeSegmentTypeEnum.NOTDEFINED + + +IfcPlateTypeEnum = enum_namespace() + + +curtain_panel = IfcPlateTypeEnum.CURTAIN_PANEL + + +sheet = IfcPlateTypeEnum.SHEET + + +flange_plate = IfcPlateTypeEnum.FLANGE_PLATE + + +web_plate = IfcPlateTypeEnum.WEB_PLATE + + +stiffener_plate = IfcPlateTypeEnum.STIFFENER_PLATE + + +gusset_plate = IfcPlateTypeEnum.GUSSET_PLATE + + +cover_plate = IfcPlateTypeEnum.COVER_PLATE + + +splice_plate = IfcPlateTypeEnum.SPLICE_PLATE + + +base_plate = IfcPlateTypeEnum.BASE_PLATE + + +userdefined = IfcPlateTypeEnum.USERDEFINED + + +notdefined = IfcPlateTypeEnum.NOTDEFINED + + +IfcPreferredSurfaceCurveRepresentation = enum_namespace() + + +curve3d = IfcPreferredSurfaceCurveRepresentation.CURVE3D + + +pcurve_s1 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S1 + + +pcurve_s2 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S2 + + +IfcProcedureTypeEnum = enum_namespace() + + +advice_caution = IfcProcedureTypeEnum.ADVICE_CAUTION + + +advice_note = IfcProcedureTypeEnum.ADVICE_NOTE + + +advice_warning = IfcProcedureTypeEnum.ADVICE_WARNING + + +calibration = IfcProcedureTypeEnum.CALIBRATION + + +diagnostic = IfcProcedureTypeEnum.DIAGNOSTIC + + +shutdown = IfcProcedureTypeEnum.SHUTDOWN + + +startup = IfcProcedureTypeEnum.STARTUP + + +userdefined = IfcProcedureTypeEnum.USERDEFINED + + +notdefined = IfcProcedureTypeEnum.NOTDEFINED + + +IfcProfileTypeEnum = enum_namespace() + + +curve = IfcProfileTypeEnum.CURVE + + +area = IfcProfileTypeEnum.AREA + + +IfcProjectOrderTypeEnum = enum_namespace() + + +changeorder = IfcProjectOrderTypeEnum.CHANGEORDER + + +maintenanceworkorder = IfcProjectOrderTypeEnum.MAINTENANCEWORKORDER + + +moveorder = IfcProjectOrderTypeEnum.MOVEORDER + + +purchaseorder = IfcProjectOrderTypeEnum.PURCHASEORDER + + +workorder = IfcProjectOrderTypeEnum.WORKORDER + + +userdefined = IfcProjectOrderTypeEnum.USERDEFINED + + +notdefined = IfcProjectOrderTypeEnum.NOTDEFINED + + +IfcProjectedOrTrueLengthEnum = enum_namespace() + + +projected_length = IfcProjectedOrTrueLengthEnum.PROJECTED_LENGTH + + +true_length = IfcProjectedOrTrueLengthEnum.TRUE_LENGTH + + +IfcProjectionElementTypeEnum = enum_namespace() + + +blister = IfcProjectionElementTypeEnum.BLISTER + + +deviator = IfcProjectionElementTypeEnum.DEVIATOR + + +userdefined = IfcProjectionElementTypeEnum.USERDEFINED + + +notdefined = IfcProjectionElementTypeEnum.NOTDEFINED + + +IfcPropertySetTemplateTypeEnum = enum_namespace() + + +pset_typedrivenonly = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENONLY + + +pset_typedrivenoverride = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENOVERRIDE + + +pset_occurrencedriven = IfcPropertySetTemplateTypeEnum.PSET_OCCURRENCEDRIVEN + + +pset_performancedriven = IfcPropertySetTemplateTypeEnum.PSET_PERFORMANCEDRIVEN + + +qto_typedrivenonly = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENONLY + + +qto_typedrivenoverride = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENOVERRIDE + + +qto_occurrencedriven = IfcPropertySetTemplateTypeEnum.QTO_OCCURRENCEDRIVEN + + +notdefined = IfcPropertySetTemplateTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTrippingUnitTypeEnum = enum_namespace() + + +electronic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTRONIC + + +electromagnetic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTROMAGNETIC + + +residualcurrent = IfcProtectiveDeviceTrippingUnitTypeEnum.RESIDUALCURRENT + + +thermal = IfcProtectiveDeviceTrippingUnitTypeEnum.THERMAL + + +userdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTypeEnum = enum_namespace() + + +circuitbreaker = IfcProtectiveDeviceTypeEnum.CIRCUITBREAKER + + +earthleakagecircuitbreaker = IfcProtectiveDeviceTypeEnum.EARTHLEAKAGECIRCUITBREAKER + + +earthingswitch = IfcProtectiveDeviceTypeEnum.EARTHINGSWITCH + + +fusedisconnector = IfcProtectiveDeviceTypeEnum.FUSEDISCONNECTOR + + +residualcurrentcircuitbreaker = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTCIRCUITBREAKER + + +residualcurrentswitch = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTSWITCH + + +varistor = IfcProtectiveDeviceTypeEnum.VARISTOR + + +anti_arcing_device = IfcProtectiveDeviceTypeEnum.ANTI_ARCING_DEVICE + + +sparkgap = IfcProtectiveDeviceTypeEnum.SPARKGAP + + +voltagelimiter = IfcProtectiveDeviceTypeEnum.VOLTAGELIMITER + + +userdefined = IfcProtectiveDeviceTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTypeEnum.NOTDEFINED + + +IfcPumpTypeEnum = enum_namespace() + + +circulator = IfcPumpTypeEnum.CIRCULATOR + + +endsuction = IfcPumpTypeEnum.ENDSUCTION + + +splitcase = IfcPumpTypeEnum.SPLITCASE + + +submersiblepump = IfcPumpTypeEnum.SUBMERSIBLEPUMP + + +sumppump = IfcPumpTypeEnum.SUMPPUMP + + +verticalinline = IfcPumpTypeEnum.VERTICALINLINE + + +verticalturbine = IfcPumpTypeEnum.VERTICALTURBINE + + +userdefined = IfcPumpTypeEnum.USERDEFINED + + +notdefined = IfcPumpTypeEnum.NOTDEFINED + + +IfcRailTypeEnum = enum_namespace() + + +rackrail = IfcRailTypeEnum.RACKRAIL + + +blade = IfcRailTypeEnum.BLADE + + +guardrail = IfcRailTypeEnum.GUARDRAIL + + +stockrail = IfcRailTypeEnum.STOCKRAIL + + +checkrail = IfcRailTypeEnum.CHECKRAIL + + +rail = IfcRailTypeEnum.RAIL + + +userdefined = IfcRailTypeEnum.USERDEFINED + + +notdefined = IfcRailTypeEnum.NOTDEFINED + + +IfcRailingTypeEnum = enum_namespace() + + +handrail = IfcRailingTypeEnum.HANDRAIL + + +guardrail = IfcRailingTypeEnum.GUARDRAIL + + +balustrade = IfcRailingTypeEnum.BALUSTRADE + + +fence = IfcRailingTypeEnum.FENCE + + +userdefined = IfcRailingTypeEnum.USERDEFINED + + +notdefined = IfcRailingTypeEnum.NOTDEFINED + + +IfcRailwayPartTypeEnum = enum_namespace() + + +trackstructure = IfcRailwayPartTypeEnum.TRACKSTRUCTURE + + +trackstructurepart = IfcRailwayPartTypeEnum.TRACKSTRUCTUREPART + + +linesidestructurepart = IfcRailwayPartTypeEnum.LINESIDESTRUCTUREPART + + +dilatationsuperstructure = IfcRailwayPartTypeEnum.DILATATIONSUPERSTRUCTURE + + +plaintracksupestructure = IfcRailwayPartTypeEnum.PLAINTRACKSUPESTRUCTURE + + +linesidestructure = IfcRailwayPartTypeEnum.LINESIDESTRUCTURE + + +superstructure = IfcRailwayPartTypeEnum.SUPERSTRUCTURE + + +turnoutsuperstructure = IfcRailwayPartTypeEnum.TURNOUTSUPERSTRUCTURE + + +userdefined = IfcRailwayPartTypeEnum.USERDEFINED + + +notdefined = IfcRailwayPartTypeEnum.NOTDEFINED + + +IfcRampFlightTypeEnum = enum_namespace() + + +straight = IfcRampFlightTypeEnum.STRAIGHT + + +spiral = IfcRampFlightTypeEnum.SPIRAL + + +userdefined = IfcRampFlightTypeEnum.USERDEFINED + + +notdefined = IfcRampFlightTypeEnum.NOTDEFINED + + +IfcRampTypeEnum = enum_namespace() + + +straight_run_ramp = IfcRampTypeEnum.STRAIGHT_RUN_RAMP + + +two_straight_run_ramp = IfcRampTypeEnum.TWO_STRAIGHT_RUN_RAMP + + +quarter_turn_ramp = IfcRampTypeEnum.QUARTER_TURN_RAMP + + +two_quarter_turn_ramp = IfcRampTypeEnum.TWO_QUARTER_TURN_RAMP + + +half_turn_ramp = IfcRampTypeEnum.HALF_TURN_RAMP + + +spiral_ramp = IfcRampTypeEnum.SPIRAL_RAMP + + +userdefined = IfcRampTypeEnum.USERDEFINED + + +notdefined = IfcRampTypeEnum.NOTDEFINED + + +IfcRecurrenceTypeEnum = enum_namespace() + + +daily = IfcRecurrenceTypeEnum.DAILY + + +weekly = IfcRecurrenceTypeEnum.WEEKLY + + +monthly_by_day_of_month = IfcRecurrenceTypeEnum.MONTHLY_BY_DAY_OF_MONTH + + +monthly_by_position = IfcRecurrenceTypeEnum.MONTHLY_BY_POSITION + + +by_day_count = IfcRecurrenceTypeEnum.BY_DAY_COUNT + + +by_weekday_count = IfcRecurrenceTypeEnum.BY_WEEKDAY_COUNT + + +yearly_by_day_of_month = IfcRecurrenceTypeEnum.YEARLY_BY_DAY_OF_MONTH + + +yearly_by_position = IfcRecurrenceTypeEnum.YEARLY_BY_POSITION + + +IfcReferentTypeEnum = enum_namespace() + + +kilopoint = IfcReferentTypeEnum.KILOPOINT + + +milepoint = IfcReferentTypeEnum.MILEPOINT + + +station = IfcReferentTypeEnum.STATION + + +referencemarker = IfcReferentTypeEnum.REFERENCEMARKER + + +userdefined = IfcReferentTypeEnum.USERDEFINED + + +notdefined = IfcReferentTypeEnum.NOTDEFINED + + +IfcReflectanceMethodEnum = enum_namespace() + + +blinn = IfcReflectanceMethodEnum.BLINN + + +flat = IfcReflectanceMethodEnum.FLAT + + +glass = IfcReflectanceMethodEnum.GLASS + + +matt = IfcReflectanceMethodEnum.MATT + + +metal = IfcReflectanceMethodEnum.METAL + + +mirror = IfcReflectanceMethodEnum.MIRROR + + +phong = IfcReflectanceMethodEnum.PHONG + + +plastic = IfcReflectanceMethodEnum.PLASTIC + + +strauss = IfcReflectanceMethodEnum.STRAUSS + + +notdefined = IfcReflectanceMethodEnum.NOTDEFINED + + +IfcReinforcedSoilTypeEnum = enum_namespace() + + +surchargepreloaded = IfcReinforcedSoilTypeEnum.SURCHARGEPRELOADED + + +verticallydrained = IfcReinforcedSoilTypeEnum.VERTICALLYDRAINED + + +dynamicallycompacted = IfcReinforcedSoilTypeEnum.DYNAMICALLYCOMPACTED + + +replaced = IfcReinforcedSoilTypeEnum.REPLACED + + +rollercompacted = IfcReinforcedSoilTypeEnum.ROLLERCOMPACTED + + +grouted = IfcReinforcedSoilTypeEnum.GROUTED + + +userdefined = IfcReinforcedSoilTypeEnum.USERDEFINED + + +notdefined = IfcReinforcedSoilTypeEnum.NOTDEFINED + + +IfcReinforcingBarRoleEnum = enum_namespace() + + +main = IfcReinforcingBarRoleEnum.MAIN + + +shear = IfcReinforcingBarRoleEnum.SHEAR + + +ligature = IfcReinforcingBarRoleEnum.LIGATURE + + +stud = IfcReinforcingBarRoleEnum.STUD + + +punching = IfcReinforcingBarRoleEnum.PUNCHING + + +edge = IfcReinforcingBarRoleEnum.EDGE + + +ring = IfcReinforcingBarRoleEnum.RING + + +anchoring = IfcReinforcingBarRoleEnum.ANCHORING + + +userdefined = IfcReinforcingBarRoleEnum.USERDEFINED + + +notdefined = IfcReinforcingBarRoleEnum.NOTDEFINED + + +IfcReinforcingBarSurfaceEnum = enum_namespace() + + +plain = IfcReinforcingBarSurfaceEnum.PLAIN + + +textured = IfcReinforcingBarSurfaceEnum.TEXTURED + + +IfcReinforcingBarTypeEnum = enum_namespace() + + +anchoring = IfcReinforcingBarTypeEnum.ANCHORING + + +edge = IfcReinforcingBarTypeEnum.EDGE + + +ligature = IfcReinforcingBarTypeEnum.LIGATURE + + +main = IfcReinforcingBarTypeEnum.MAIN + + +punching = IfcReinforcingBarTypeEnum.PUNCHING + + +ring = IfcReinforcingBarTypeEnum.RING + + +shear = IfcReinforcingBarTypeEnum.SHEAR + + +stud = IfcReinforcingBarTypeEnum.STUD + + +spacebar = IfcReinforcingBarTypeEnum.SPACEBAR + + +userdefined = IfcReinforcingBarTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingBarTypeEnum.NOTDEFINED + + +IfcReinforcingMeshTypeEnum = enum_namespace() + + +userdefined = IfcReinforcingMeshTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingMeshTypeEnum.NOTDEFINED + + +IfcRoadPartTypeEnum = enum_namespace() + + +roadsidepart = IfcRoadPartTypeEnum.ROADSIDEPART + + +bus_stop = IfcRoadPartTypeEnum.BUS_STOP + + +hardshoulder = IfcRoadPartTypeEnum.HARDSHOULDER + + +intersection = IfcRoadPartTypeEnum.INTERSECTION + + +passingbay = IfcRoadPartTypeEnum.PASSINGBAY + + +roadwayplateau = IfcRoadPartTypeEnum.ROADWAYPLATEAU + + +roadside = IfcRoadPartTypeEnum.ROADSIDE + + +refugeisland = IfcRoadPartTypeEnum.REFUGEISLAND + + +tollplaza = IfcRoadPartTypeEnum.TOLLPLAZA + + +centralreserve = IfcRoadPartTypeEnum.CENTRALRESERVE + + +sidewalk = IfcRoadPartTypeEnum.SIDEWALK + + +parkingbay = IfcRoadPartTypeEnum.PARKINGBAY + + +railwaycrossing = IfcRoadPartTypeEnum.RAILWAYCROSSING + + +pedestrian_crossing = IfcRoadPartTypeEnum.PEDESTRIAN_CROSSING + + +softshoulder = IfcRoadPartTypeEnum.SOFTSHOULDER + + +bicyclecrossing = IfcRoadPartTypeEnum.BICYCLECROSSING + + +centralisland = IfcRoadPartTypeEnum.CENTRALISLAND + + +shoulder = IfcRoadPartTypeEnum.SHOULDER + + +trafficlane = IfcRoadPartTypeEnum.TRAFFICLANE + + +roadsegment = IfcRoadPartTypeEnum.ROADSEGMENT + + +roundabout = IfcRoadPartTypeEnum.ROUNDABOUT + + +layby = IfcRoadPartTypeEnum.LAYBY + + +carriageway = IfcRoadPartTypeEnum.CARRIAGEWAY + + +trafficisland = IfcRoadPartTypeEnum.TRAFFICISLAND + + +userdefined = IfcRoadPartTypeEnum.USERDEFINED + + +notdefined = IfcRoadPartTypeEnum.NOTDEFINED + + +IfcRoleEnum = enum_namespace() + + +supplier = IfcRoleEnum.SUPPLIER + + +manufacturer = IfcRoleEnum.MANUFACTURER + + +contractor = IfcRoleEnum.CONTRACTOR + + +subcontractor = IfcRoleEnum.SUBCONTRACTOR + + +architect = IfcRoleEnum.ARCHITECT + + +structuralengineer = IfcRoleEnum.STRUCTURALENGINEER + + +costengineer = IfcRoleEnum.COSTENGINEER + + +client = IfcRoleEnum.CLIENT + + +buildingowner = IfcRoleEnum.BUILDINGOWNER + + +buildingoperator = IfcRoleEnum.BUILDINGOPERATOR + + +mechanicalengineer = IfcRoleEnum.MECHANICALENGINEER + + +electricalengineer = IfcRoleEnum.ELECTRICALENGINEER + + +projectmanager = IfcRoleEnum.PROJECTMANAGER + + +facilitiesmanager = IfcRoleEnum.FACILITIESMANAGER + + +civilengineer = IfcRoleEnum.CIVILENGINEER + + +commissioningengineer = IfcRoleEnum.COMMISSIONINGENGINEER + + +engineer = IfcRoleEnum.ENGINEER + + +owner = IfcRoleEnum.OWNER + + +consultant = IfcRoleEnum.CONSULTANT + + +constructionmanager = IfcRoleEnum.CONSTRUCTIONMANAGER + + +fieldconstructionmanager = IfcRoleEnum.FIELDCONSTRUCTIONMANAGER + + +reseller = IfcRoleEnum.RESELLER + + +userdefined = IfcRoleEnum.USERDEFINED + + +IfcRoofTypeEnum = enum_namespace() + + +flat_roof = IfcRoofTypeEnum.FLAT_ROOF + + +shed_roof = IfcRoofTypeEnum.SHED_ROOF + + +gable_roof = IfcRoofTypeEnum.GABLE_ROOF + + +hip_roof = IfcRoofTypeEnum.HIP_ROOF + + +hipped_gable_roof = IfcRoofTypeEnum.HIPPED_GABLE_ROOF + + +gambrel_roof = IfcRoofTypeEnum.GAMBREL_ROOF + + +mansard_roof = IfcRoofTypeEnum.MANSARD_ROOF + + +barrel_roof = IfcRoofTypeEnum.BARREL_ROOF + + +rainbow_roof = IfcRoofTypeEnum.RAINBOW_ROOF + + +butterfly_roof = IfcRoofTypeEnum.BUTTERFLY_ROOF + + +pavilion_roof = IfcRoofTypeEnum.PAVILION_ROOF + + +dome_roof = IfcRoofTypeEnum.DOME_ROOF + + +freeform = IfcRoofTypeEnum.FREEFORM + + +userdefined = IfcRoofTypeEnum.USERDEFINED + + +notdefined = IfcRoofTypeEnum.NOTDEFINED + + +IfcSIPrefix = enum_namespace() + + +exa = IfcSIPrefix.EXA + + +peta = IfcSIPrefix.PETA + + +tera = IfcSIPrefix.TERA + + +giga = IfcSIPrefix.GIGA + + +mega = IfcSIPrefix.MEGA + + +kilo = IfcSIPrefix.KILO + + +hecto = IfcSIPrefix.HECTO + + +deca = IfcSIPrefix.DECA + + +deci = IfcSIPrefix.DECI + + +centi = IfcSIPrefix.CENTI + + +milli = IfcSIPrefix.MILLI + + +micro = IfcSIPrefix.MICRO + + +nano = IfcSIPrefix.NANO + + +pico = IfcSIPrefix.PICO + + +femto = IfcSIPrefix.FEMTO + + +atto = IfcSIPrefix.ATTO + + +IfcSIUnitName = enum_namespace() + + +ampere = IfcSIUnitName.AMPERE + + +becquerel = IfcSIUnitName.BECQUEREL + + +candela = IfcSIUnitName.CANDELA + + +coulomb = IfcSIUnitName.COULOMB + + +cubic_metre = IfcSIUnitName.CUBIC_METRE + + +degree_celsius = IfcSIUnitName.DEGREE_CELSIUS + + +farad = IfcSIUnitName.FARAD + + +gram = IfcSIUnitName.GRAM + + +gray = IfcSIUnitName.GRAY + + +henry = IfcSIUnitName.HENRY + + +hertz = IfcSIUnitName.HERTZ + + +joule = IfcSIUnitName.JOULE + + +kelvin = IfcSIUnitName.KELVIN + + +lumen = IfcSIUnitName.LUMEN + + +lux = IfcSIUnitName.LUX + + +metre = IfcSIUnitName.METRE + + +mole = IfcSIUnitName.MOLE + + +newton = IfcSIUnitName.NEWTON + + +ohm = IfcSIUnitName.OHM + + +pascal = IfcSIUnitName.PASCAL + + +radian = IfcSIUnitName.RADIAN + + +second = IfcSIUnitName.SECOND + + +siemens = IfcSIUnitName.SIEMENS + + +sievert = IfcSIUnitName.SIEVERT + + +square_metre = IfcSIUnitName.SQUARE_METRE + + +steradian = IfcSIUnitName.STERADIAN + + +tesla = IfcSIUnitName.TESLA + + +volt = IfcSIUnitName.VOLT + + +watt = IfcSIUnitName.WATT + + +weber = IfcSIUnitName.WEBER + + +IfcSanitaryTerminalTypeEnum = enum_namespace() + + +bath = IfcSanitaryTerminalTypeEnum.BATH + + +bidet = IfcSanitaryTerminalTypeEnum.BIDET + + +cistern = IfcSanitaryTerminalTypeEnum.CISTERN + + +shower = IfcSanitaryTerminalTypeEnum.SHOWER + + +sink = IfcSanitaryTerminalTypeEnum.SINK + + +sanitaryfountain = IfcSanitaryTerminalTypeEnum.SANITARYFOUNTAIN + + +toiletpan = IfcSanitaryTerminalTypeEnum.TOILETPAN + + +urinal = IfcSanitaryTerminalTypeEnum.URINAL + + +washhandbasin = IfcSanitaryTerminalTypeEnum.WASHHANDBASIN + + +wcseat = IfcSanitaryTerminalTypeEnum.WCSEAT + + +userdefined = IfcSanitaryTerminalTypeEnum.USERDEFINED + + +notdefined = IfcSanitaryTerminalTypeEnum.NOTDEFINED + + +IfcSectionTypeEnum = enum_namespace() + + +uniform = IfcSectionTypeEnum.UNIFORM + + +tapered = IfcSectionTypeEnum.TAPERED + + +IfcSensorTypeEnum = enum_namespace() + + +cosensor = IfcSensorTypeEnum.COSENSOR + + +co2sensor = IfcSensorTypeEnum.CO2SENSOR + + +conductancesensor = IfcSensorTypeEnum.CONDUCTANCESENSOR + + +contactsensor = IfcSensorTypeEnum.CONTACTSENSOR + + +firesensor = IfcSensorTypeEnum.FIRESENSOR + + +flowsensor = IfcSensorTypeEnum.FLOWSENSOR + + +frostsensor = IfcSensorTypeEnum.FROSTSENSOR + + +gassensor = IfcSensorTypeEnum.GASSENSOR + + +heatsensor = IfcSensorTypeEnum.HEATSENSOR + + +humiditysensor = IfcSensorTypeEnum.HUMIDITYSENSOR + + +identifiersensor = IfcSensorTypeEnum.IDENTIFIERSENSOR + + +ionconcentrationsensor = IfcSensorTypeEnum.IONCONCENTRATIONSENSOR + + +levelsensor = IfcSensorTypeEnum.LEVELSENSOR + + +lightsensor = IfcSensorTypeEnum.LIGHTSENSOR + + +moisturesensor = IfcSensorTypeEnum.MOISTURESENSOR + + +movementsensor = IfcSensorTypeEnum.MOVEMENTSENSOR + + +phsensor = IfcSensorTypeEnum.PHSENSOR + + +pressuresensor = IfcSensorTypeEnum.PRESSURESENSOR + + +radiationsensor = IfcSensorTypeEnum.RADIATIONSENSOR + + +radioactivitysensor = IfcSensorTypeEnum.RADIOACTIVITYSENSOR + + +smokesensor = IfcSensorTypeEnum.SMOKESENSOR + + +soundsensor = IfcSensorTypeEnum.SOUNDSENSOR + + +temperaturesensor = IfcSensorTypeEnum.TEMPERATURESENSOR + + +windsensor = IfcSensorTypeEnum.WINDSENSOR + + +earthquakesensor = IfcSensorTypeEnum.EARTHQUAKESENSOR + + +foreignobjectdetectionsensor = IfcSensorTypeEnum.FOREIGNOBJECTDETECTIONSENSOR + + +obstaclesensor = IfcSensorTypeEnum.OBSTACLESENSOR + + +rainsensor = IfcSensorTypeEnum.RAINSENSOR + + +snowdepthsensor = IfcSensorTypeEnum.SNOWDEPTHSENSOR + + +trainsensor = IfcSensorTypeEnum.TRAINSENSOR + + +turnoutclosuresensor = IfcSensorTypeEnum.TURNOUTCLOSURESENSOR + + +wheelsensor = IfcSensorTypeEnum.WHEELSENSOR + + +userdefined = IfcSensorTypeEnum.USERDEFINED + + +notdefined = IfcSensorTypeEnum.NOTDEFINED + + +IfcSequenceEnum = enum_namespace() + + +start_start = IfcSequenceEnum.START_START + + +start_finish = IfcSequenceEnum.START_FINISH + + +finish_start = IfcSequenceEnum.FINISH_START + + +finish_finish = IfcSequenceEnum.FINISH_FINISH + + +userdefined = IfcSequenceEnum.USERDEFINED + + +notdefined = IfcSequenceEnum.NOTDEFINED + + +IfcShadingDeviceTypeEnum = enum_namespace() + + +jalousie = IfcShadingDeviceTypeEnum.JALOUSIE + + +shutter = IfcShadingDeviceTypeEnum.SHUTTER + + +awning = IfcShadingDeviceTypeEnum.AWNING + + +userdefined = IfcShadingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcShadingDeviceTypeEnum.NOTDEFINED + + +IfcSignTypeEnum = enum_namespace() + + +marker = IfcSignTypeEnum.MARKER + + +pictoral = IfcSignTypeEnum.PICTORAL + + +mirror = IfcSignTypeEnum.MIRROR + + +userdefined = IfcSignTypeEnum.USERDEFINED + + +notdefined = IfcSignTypeEnum.NOTDEFINED + + +IfcSignalTypeEnum = enum_namespace() + + +visual = IfcSignalTypeEnum.VISUAL + + +audio = IfcSignalTypeEnum.AUDIO + + +mixed = IfcSignalTypeEnum.MIXED + + +userdefined = IfcSignalTypeEnum.USERDEFINED + + +notdefined = IfcSignalTypeEnum.NOTDEFINED + + +IfcSimplePropertyTemplateTypeEnum = enum_namespace() + + +p_singlevalue = IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE + + +p_enumeratedvalue = IfcSimplePropertyTemplateTypeEnum.P_ENUMERATEDVALUE + + +p_boundedvalue = IfcSimplePropertyTemplateTypeEnum.P_BOUNDEDVALUE + + +p_listvalue = IfcSimplePropertyTemplateTypeEnum.P_LISTVALUE + + +p_tablevalue = IfcSimplePropertyTemplateTypeEnum.P_TABLEVALUE + + +p_referencevalue = IfcSimplePropertyTemplateTypeEnum.P_REFERENCEVALUE + + +q_length = IfcSimplePropertyTemplateTypeEnum.Q_LENGTH + + +q_area = IfcSimplePropertyTemplateTypeEnum.Q_AREA + + +q_volume = IfcSimplePropertyTemplateTypeEnum.Q_VOLUME + + +q_count = IfcSimplePropertyTemplateTypeEnum.Q_COUNT + + +q_weight = IfcSimplePropertyTemplateTypeEnum.Q_WEIGHT + + +q_time = IfcSimplePropertyTemplateTypeEnum.Q_TIME + + +IfcSlabTypeEnum = enum_namespace() + + +floor = IfcSlabTypeEnum.FLOOR + + +roof = IfcSlabTypeEnum.ROOF + + +landing = IfcSlabTypeEnum.LANDING + + +baseslab = IfcSlabTypeEnum.BASESLAB + + +approach_slab = IfcSlabTypeEnum.APPROACH_SLAB + + +paving = IfcSlabTypeEnum.PAVING + + +wearing = IfcSlabTypeEnum.WEARING + + +sidewalk = IfcSlabTypeEnum.SIDEWALK + + +trackslab = IfcSlabTypeEnum.TRACKSLAB + + +userdefined = IfcSlabTypeEnum.USERDEFINED + + +notdefined = IfcSlabTypeEnum.NOTDEFINED + + +IfcSolarDeviceTypeEnum = enum_namespace() + + +solarcollector = IfcSolarDeviceTypeEnum.SOLARCOLLECTOR + + +solarpanel = IfcSolarDeviceTypeEnum.SOLARPANEL + + +userdefined = IfcSolarDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSolarDeviceTypeEnum.NOTDEFINED + + +IfcSpaceHeaterTypeEnum = enum_namespace() + + +convector = IfcSpaceHeaterTypeEnum.CONVECTOR + + +radiator = IfcSpaceHeaterTypeEnum.RADIATOR + + +userdefined = IfcSpaceHeaterTypeEnum.USERDEFINED + + +notdefined = IfcSpaceHeaterTypeEnum.NOTDEFINED + + +IfcSpaceTypeEnum = enum_namespace() + + +space = IfcSpaceTypeEnum.SPACE + + +parking = IfcSpaceTypeEnum.PARKING + + +gfa = IfcSpaceTypeEnum.GFA + + +internal = IfcSpaceTypeEnum.INTERNAL + + +external = IfcSpaceTypeEnum.EXTERNAL + + +userdefined = IfcSpaceTypeEnum.USERDEFINED + + +notdefined = IfcSpaceTypeEnum.NOTDEFINED + + +IfcSpatialZoneTypeEnum = enum_namespace() + + +construction = IfcSpatialZoneTypeEnum.CONSTRUCTION + + +firesafety = IfcSpatialZoneTypeEnum.FIRESAFETY + + +lighting = IfcSpatialZoneTypeEnum.LIGHTING + + +occupancy = IfcSpatialZoneTypeEnum.OCCUPANCY + + +security = IfcSpatialZoneTypeEnum.SECURITY + + +thermal = IfcSpatialZoneTypeEnum.THERMAL + + +transport = IfcSpatialZoneTypeEnum.TRANSPORT + + +ventilation = IfcSpatialZoneTypeEnum.VENTILATION + + +reservation = IfcSpatialZoneTypeEnum.RESERVATION + + +userdefined = IfcSpatialZoneTypeEnum.USERDEFINED + + +notdefined = IfcSpatialZoneTypeEnum.NOTDEFINED + + +IfcStackTerminalTypeEnum = enum_namespace() + + +birdcage = IfcStackTerminalTypeEnum.BIRDCAGE + + +cowl = IfcStackTerminalTypeEnum.COWL + + +rainwaterhopper = IfcStackTerminalTypeEnum.RAINWATERHOPPER + + +userdefined = IfcStackTerminalTypeEnum.USERDEFINED + + +notdefined = IfcStackTerminalTypeEnum.NOTDEFINED + + +IfcStairFlightTypeEnum = enum_namespace() + + +straight = IfcStairFlightTypeEnum.STRAIGHT + + +winder = IfcStairFlightTypeEnum.WINDER + + +spiral = IfcStairFlightTypeEnum.SPIRAL + + +curved = IfcStairFlightTypeEnum.CURVED + + +freeform = IfcStairFlightTypeEnum.FREEFORM + + +userdefined = IfcStairFlightTypeEnum.USERDEFINED + + +notdefined = IfcStairFlightTypeEnum.NOTDEFINED + + +IfcStairTypeEnum = enum_namespace() + + +straight_run_stair = IfcStairTypeEnum.STRAIGHT_RUN_STAIR + + +two_straight_run_stair = IfcStairTypeEnum.TWO_STRAIGHT_RUN_STAIR + + +quarter_winding_stair = IfcStairTypeEnum.QUARTER_WINDING_STAIR + + +quarter_turn_stair = IfcStairTypeEnum.QUARTER_TURN_STAIR + + +half_winding_stair = IfcStairTypeEnum.HALF_WINDING_STAIR + + +half_turn_stair = IfcStairTypeEnum.HALF_TURN_STAIR + + +two_quarter_winding_stair = IfcStairTypeEnum.TWO_QUARTER_WINDING_STAIR + + +two_quarter_turn_stair = IfcStairTypeEnum.TWO_QUARTER_TURN_STAIR + + +three_quarter_winding_stair = IfcStairTypeEnum.THREE_QUARTER_WINDING_STAIR + + +three_quarter_turn_stair = IfcStairTypeEnum.THREE_QUARTER_TURN_STAIR + + +spiral_stair = IfcStairTypeEnum.SPIRAL_STAIR + + +double_return_stair = IfcStairTypeEnum.DOUBLE_RETURN_STAIR + + +curved_run_stair = IfcStairTypeEnum.CURVED_RUN_STAIR + + +two_curved_run_stair = IfcStairTypeEnum.TWO_CURVED_RUN_STAIR + + +ladder = IfcStairTypeEnum.LADDER + + +userdefined = IfcStairTypeEnum.USERDEFINED + + +notdefined = IfcStairTypeEnum.NOTDEFINED + + +IfcStateEnum = enum_namespace() + + +readwrite = IfcStateEnum.READWRITE + + +readonly = IfcStateEnum.READONLY + + +locked = IfcStateEnum.LOCKED + + +readwritelocked = IfcStateEnum.READWRITELOCKED + + +readonlylocked = IfcStateEnum.READONLYLOCKED + + +IfcStructuralCurveActivityTypeEnum = enum_namespace() + + +const = IfcStructuralCurveActivityTypeEnum.CONST + + +linear = IfcStructuralCurveActivityTypeEnum.LINEAR + + +polygonal = IfcStructuralCurveActivityTypeEnum.POLYGONAL + + +equidistant = IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + +sinus = IfcStructuralCurveActivityTypeEnum.SINUS + + +parabola = IfcStructuralCurveActivityTypeEnum.PARABOLA + + +discrete = IfcStructuralCurveActivityTypeEnum.DISCRETE + + +userdefined = IfcStructuralCurveActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveActivityTypeEnum.NOTDEFINED + + +IfcStructuralCurveMemberTypeEnum = enum_namespace() + + +rigid_joined_member = IfcStructuralCurveMemberTypeEnum.RIGID_JOINED_MEMBER + + +pin_joined_member = IfcStructuralCurveMemberTypeEnum.PIN_JOINED_MEMBER + + +cable = IfcStructuralCurveMemberTypeEnum.CABLE + + +tension_member = IfcStructuralCurveMemberTypeEnum.TENSION_MEMBER + + +compression_member = IfcStructuralCurveMemberTypeEnum.COMPRESSION_MEMBER + + +userdefined = IfcStructuralCurveMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveMemberTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceActivityTypeEnum = enum_namespace() + + +const = IfcStructuralSurfaceActivityTypeEnum.CONST + + +bilinear = IfcStructuralSurfaceActivityTypeEnum.BILINEAR + + +discrete = IfcStructuralSurfaceActivityTypeEnum.DISCRETE + + +isocontour = IfcStructuralSurfaceActivityTypeEnum.ISOCONTOUR + + +userdefined = IfcStructuralSurfaceActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceActivityTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceMemberTypeEnum = enum_namespace() + + +bending_element = IfcStructuralSurfaceMemberTypeEnum.BENDING_ELEMENT + + +membrane_element = IfcStructuralSurfaceMemberTypeEnum.MEMBRANE_ELEMENT + + +shell = IfcStructuralSurfaceMemberTypeEnum.SHELL + + +userdefined = IfcStructuralSurfaceMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceMemberTypeEnum.NOTDEFINED + + +IfcSubContractResourceTypeEnum = enum_namespace() + + +purchase = IfcSubContractResourceTypeEnum.PURCHASE + + +work = IfcSubContractResourceTypeEnum.WORK + + +userdefined = IfcSubContractResourceTypeEnum.USERDEFINED + + +notdefined = IfcSubContractResourceTypeEnum.NOTDEFINED + + +IfcSurfaceFeatureTypeEnum = enum_namespace() + + +mark = IfcSurfaceFeatureTypeEnum.MARK + + +tag = IfcSurfaceFeatureTypeEnum.TAG + + +treatment = IfcSurfaceFeatureTypeEnum.TREATMENT + + +defect = IfcSurfaceFeatureTypeEnum.DEFECT + + +hatchmarking = IfcSurfaceFeatureTypeEnum.HATCHMARKING + + +linemarking = IfcSurfaceFeatureTypeEnum.LINEMARKING + + +pavementsurfacemarking = IfcSurfaceFeatureTypeEnum.PAVEMENTSURFACEMARKING + + +symbolmarking = IfcSurfaceFeatureTypeEnum.SYMBOLMARKING + + +nonskidsurfacing = IfcSurfaceFeatureTypeEnum.NONSKIDSURFACING + + +rumblestrip = IfcSurfaceFeatureTypeEnum.RUMBLESTRIP + + +transverserumblestrip = IfcSurfaceFeatureTypeEnum.TRANSVERSERUMBLESTRIP + + +userdefined = IfcSurfaceFeatureTypeEnum.USERDEFINED + + +notdefined = IfcSurfaceFeatureTypeEnum.NOTDEFINED + + +IfcSurfaceSide = enum_namespace() + + +positive = IfcSurfaceSide.POSITIVE + + +negative = IfcSurfaceSide.NEGATIVE + + +both = IfcSurfaceSide.BOTH + + +IfcSwitchingDeviceTypeEnum = enum_namespace() + + +contactor = IfcSwitchingDeviceTypeEnum.CONTACTOR + + +dimmerswitch = IfcSwitchingDeviceTypeEnum.DIMMERSWITCH + + +emergencystop = IfcSwitchingDeviceTypeEnum.EMERGENCYSTOP + + +keypad = IfcSwitchingDeviceTypeEnum.KEYPAD + + +momentaryswitch = IfcSwitchingDeviceTypeEnum.MOMENTARYSWITCH + + +selectorswitch = IfcSwitchingDeviceTypeEnum.SELECTORSWITCH + + +starter = IfcSwitchingDeviceTypeEnum.STARTER + + +switchdisconnector = IfcSwitchingDeviceTypeEnum.SWITCHDISCONNECTOR + + +toggleswitch = IfcSwitchingDeviceTypeEnum.TOGGLESWITCH + + +relay = IfcSwitchingDeviceTypeEnum.RELAY + + +start_and_stop_equipment = IfcSwitchingDeviceTypeEnum.START_AND_STOP_EQUIPMENT + + +userdefined = IfcSwitchingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSwitchingDeviceTypeEnum.NOTDEFINED + + +IfcSystemFurnitureElementTypeEnum = enum_namespace() + + +panel = IfcSystemFurnitureElementTypeEnum.PANEL + + +worksurface = IfcSystemFurnitureElementTypeEnum.WORKSURFACE + + +subrack = IfcSystemFurnitureElementTypeEnum.SUBRACK + + +userdefined = IfcSystemFurnitureElementTypeEnum.USERDEFINED + + +notdefined = IfcSystemFurnitureElementTypeEnum.NOTDEFINED + + +IfcTankTypeEnum = enum_namespace() + + +basin = IfcTankTypeEnum.BASIN + + +breakpressure = IfcTankTypeEnum.BREAKPRESSURE + + +expansion = IfcTankTypeEnum.EXPANSION + + +feedandexpansion = IfcTankTypeEnum.FEEDANDEXPANSION + + +pressurevessel = IfcTankTypeEnum.PRESSUREVESSEL + + +storage = IfcTankTypeEnum.STORAGE + + +vessel = IfcTankTypeEnum.VESSEL + + +oilretentiontray = IfcTankTypeEnum.OILRETENTIONTRAY + + +userdefined = IfcTankTypeEnum.USERDEFINED + + +notdefined = IfcTankTypeEnum.NOTDEFINED + + +IfcTaskDurationEnum = enum_namespace() + + +elapsedtime = IfcTaskDurationEnum.ELAPSEDTIME + + +worktime = IfcTaskDurationEnum.WORKTIME + + +notdefined = IfcTaskDurationEnum.NOTDEFINED + + +IfcTaskTypeEnum = enum_namespace() + + +attendance = IfcTaskTypeEnum.ATTENDANCE + + +construction = IfcTaskTypeEnum.CONSTRUCTION + + +demolition = IfcTaskTypeEnum.DEMOLITION + + +dismantle = IfcTaskTypeEnum.DISMANTLE + + +disposal = IfcTaskTypeEnum.DISPOSAL + + +installation = IfcTaskTypeEnum.INSTALLATION + + +logistic = IfcTaskTypeEnum.LOGISTIC + + +maintenance = IfcTaskTypeEnum.MAINTENANCE + + +move = IfcTaskTypeEnum.MOVE + + +operation = IfcTaskTypeEnum.OPERATION + + +removal = IfcTaskTypeEnum.REMOVAL + + +renovation = IfcTaskTypeEnum.RENOVATION + + +userdefined = IfcTaskTypeEnum.USERDEFINED + + +notdefined = IfcTaskTypeEnum.NOTDEFINED + + +IfcTendonAnchorTypeEnum = enum_namespace() + + +coupler = IfcTendonAnchorTypeEnum.COUPLER + + +fixed_end = IfcTendonAnchorTypeEnum.FIXED_END + + +tensioning_end = IfcTendonAnchorTypeEnum.TENSIONING_END + + +userdefined = IfcTendonAnchorTypeEnum.USERDEFINED + + +notdefined = IfcTendonAnchorTypeEnum.NOTDEFINED + + +IfcTendonConduitTypeEnum = enum_namespace() + + +duct = IfcTendonConduitTypeEnum.DUCT + + +coupler = IfcTendonConduitTypeEnum.COUPLER + + +grouting_duct = IfcTendonConduitTypeEnum.GROUTING_DUCT + + +trumpet = IfcTendonConduitTypeEnum.TRUMPET + + +diabolo = IfcTendonConduitTypeEnum.DIABOLO + + +userdefined = IfcTendonConduitTypeEnum.USERDEFINED + + +notdefined = IfcTendonConduitTypeEnum.NOTDEFINED + + +IfcTendonTypeEnum = enum_namespace() + + +bar = IfcTendonTypeEnum.BAR + + +coated = IfcTendonTypeEnum.COATED + + +strand = IfcTendonTypeEnum.STRAND + + +wire = IfcTendonTypeEnum.WIRE + + +userdefined = IfcTendonTypeEnum.USERDEFINED + + +notdefined = IfcTendonTypeEnum.NOTDEFINED + + +IfcTextPath = enum_namespace() + + +left = IfcTextPath.LEFT + + +right = IfcTextPath.RIGHT + + +up = IfcTextPath.UP + + +down = IfcTextPath.DOWN + + +IfcTimeSeriesDataTypeEnum = enum_namespace() + + +continuous = IfcTimeSeriesDataTypeEnum.CONTINUOUS + + +discrete = IfcTimeSeriesDataTypeEnum.DISCRETE + + +discretebinary = IfcTimeSeriesDataTypeEnum.DISCRETEBINARY + + +piecewisebinary = IfcTimeSeriesDataTypeEnum.PIECEWISEBINARY + + +piecewiseconstant = IfcTimeSeriesDataTypeEnum.PIECEWISECONSTANT + + +piecewisecontinuous = IfcTimeSeriesDataTypeEnum.PIECEWISECONTINUOUS + + +notdefined = IfcTimeSeriesDataTypeEnum.NOTDEFINED + + +IfcTrackElementTypeEnum = enum_namespace() + + +trackendofalignment = IfcTrackElementTypeEnum.TRACKENDOFALIGNMENT + + +blockingdevice = IfcTrackElementTypeEnum.BLOCKINGDEVICE + + +vehiclestop = IfcTrackElementTypeEnum.VEHICLESTOP + + +sleeper = IfcTrackElementTypeEnum.SLEEPER + + +half_set_of_blades = IfcTrackElementTypeEnum.HALF_SET_OF_BLADES + + +speedregulator = IfcTrackElementTypeEnum.SPEEDREGULATOR + + +derailer = IfcTrackElementTypeEnum.DERAILER + + +frog = IfcTrackElementTypeEnum.FROG + + +userdefined = IfcTrackElementTypeEnum.USERDEFINED + + +notdefined = IfcTrackElementTypeEnum.NOTDEFINED + + +IfcTransformerTypeEnum = enum_namespace() + + +current = IfcTransformerTypeEnum.CURRENT + + +frequency = IfcTransformerTypeEnum.FREQUENCY + + +inverter = IfcTransformerTypeEnum.INVERTER + + +rectifier = IfcTransformerTypeEnum.RECTIFIER + + +voltage = IfcTransformerTypeEnum.VOLTAGE + + +chopper = IfcTransformerTypeEnum.CHOPPER + + +combined = IfcTransformerTypeEnum.COMBINED + + +userdefined = IfcTransformerTypeEnum.USERDEFINED + + +notdefined = IfcTransformerTypeEnum.NOTDEFINED + + +IfcTransitionCode = enum_namespace() + + +discontinuous = IfcTransitionCode.DISCONTINUOUS + + +continuous = IfcTransitionCode.CONTINUOUS + + +contsamegradient = IfcTransitionCode.CONTSAMEGRADIENT + + +contsamegradientsamecurvature = IfcTransitionCode.CONTSAMEGRADIENTSAMECURVATURE + + +IfcTransitionCurveType = enum_namespace() + + +biquadraticparabola = IfcTransitionCurveType.BIQUADRATICPARABOLA + + +blosscurve = IfcTransitionCurveType.BLOSSCURVE + + +clothoidcurve = IfcTransitionCurveType.CLOTHOIDCURVE + + +cosinecurve = IfcTransitionCurveType.COSINECURVE + + +cubicparabola = IfcTransitionCurveType.CUBICPARABOLA + + +sinecurve = IfcTransitionCurveType.SINECURVE + + +IfcTransportElementFixedTypeEnum = enum_namespace() + + +elevator = IfcTransportElementFixedTypeEnum.ELEVATOR + + +escalator = IfcTransportElementFixedTypeEnum.ESCALATOR + + +movingwalkway = IfcTransportElementFixedTypeEnum.MOVINGWALKWAY + + +craneway = IfcTransportElementFixedTypeEnum.CRANEWAY + + +liftinggear = IfcTransportElementFixedTypeEnum.LIFTINGGEAR + + +userdefined = IfcTransportElementFixedTypeEnum.USERDEFINED + + +notdefined = IfcTransportElementFixedTypeEnum.NOTDEFINED + + +IfcTransportElementNonFixedTypeEnum = enum_namespace() + + +vehicle = IfcTransportElementNonFixedTypeEnum.VEHICLE + + +vehicletracked = IfcTransportElementNonFixedTypeEnum.VEHICLETRACKED + + +rollingstock = IfcTransportElementNonFixedTypeEnum.ROLLINGSTOCK + + +vehiclewheeled = IfcTransportElementNonFixedTypeEnum.VEHICLEWHEELED + + +vehicleair = IfcTransportElementNonFixedTypeEnum.VEHICLEAIR + + +cargo = IfcTransportElementNonFixedTypeEnum.CARGO + + +vehiclemarine = IfcTransportElementNonFixedTypeEnum.VEHICLEMARINE + + +userdefined = IfcTransportElementNonFixedTypeEnum.USERDEFINED + + +notdefined = IfcTransportElementNonFixedTypeEnum.NOTDEFINED + + +IfcTrimmingPreference = enum_namespace() + + +cartesian = IfcTrimmingPreference.CARTESIAN + + +parameter = IfcTrimmingPreference.PARAMETER + + +unspecified = IfcTrimmingPreference.UNSPECIFIED + + +IfcTubeBundleTypeEnum = enum_namespace() + + +finned = IfcTubeBundleTypeEnum.FINNED + + +userdefined = IfcTubeBundleTypeEnum.USERDEFINED + + +notdefined = IfcTubeBundleTypeEnum.NOTDEFINED + + +IfcUnitEnum = enum_namespace() + + +absorbeddoseunit = IfcUnitEnum.ABSORBEDDOSEUNIT + + +amountofsubstanceunit = IfcUnitEnum.AMOUNTOFSUBSTANCEUNIT + + +areaunit = IfcUnitEnum.AREAUNIT + + +doseequivalentunit = IfcUnitEnum.DOSEEQUIVALENTUNIT + + +electriccapacitanceunit = IfcUnitEnum.ELECTRICCAPACITANCEUNIT + + +electricchargeunit = IfcUnitEnum.ELECTRICCHARGEUNIT + + +electricconductanceunit = IfcUnitEnum.ELECTRICCONDUCTANCEUNIT + + +electriccurrentunit = IfcUnitEnum.ELECTRICCURRENTUNIT + + +electricresistanceunit = IfcUnitEnum.ELECTRICRESISTANCEUNIT + + +electricvoltageunit = IfcUnitEnum.ELECTRICVOLTAGEUNIT + + +energyunit = IfcUnitEnum.ENERGYUNIT + + +forceunit = IfcUnitEnum.FORCEUNIT + + +frequencyunit = IfcUnitEnum.FREQUENCYUNIT + + +illuminanceunit = IfcUnitEnum.ILLUMINANCEUNIT + + +inductanceunit = IfcUnitEnum.INDUCTANCEUNIT + + +lengthunit = IfcUnitEnum.LENGTHUNIT + + +luminousfluxunit = IfcUnitEnum.LUMINOUSFLUXUNIT + + +luminousintensityunit = IfcUnitEnum.LUMINOUSINTENSITYUNIT + + +magneticfluxdensityunit = IfcUnitEnum.MAGNETICFLUXDENSITYUNIT + + +magneticfluxunit = IfcUnitEnum.MAGNETICFLUXUNIT + + +massunit = IfcUnitEnum.MASSUNIT + + +planeangleunit = IfcUnitEnum.PLANEANGLEUNIT + + +powerunit = IfcUnitEnum.POWERUNIT + + +pressureunit = IfcUnitEnum.PRESSUREUNIT + + +radioactivityunit = IfcUnitEnum.RADIOACTIVITYUNIT + + +solidangleunit = IfcUnitEnum.SOLIDANGLEUNIT + + +thermodynamictemperatureunit = IfcUnitEnum.THERMODYNAMICTEMPERATUREUNIT + + +timeunit = IfcUnitEnum.TIMEUNIT + + +volumeunit = IfcUnitEnum.VOLUMEUNIT + + +userdefined = IfcUnitEnum.USERDEFINED + + +IfcUnitaryControlElementTypeEnum = enum_namespace() + + +alarmpanel = IfcUnitaryControlElementTypeEnum.ALARMPANEL + + +controlpanel = IfcUnitaryControlElementTypeEnum.CONTROLPANEL + + +gasdetectionpanel = IfcUnitaryControlElementTypeEnum.GASDETECTIONPANEL + + +indicatorpanel = IfcUnitaryControlElementTypeEnum.INDICATORPANEL + + +mimicpanel = IfcUnitaryControlElementTypeEnum.MIMICPANEL + + +humidistat = IfcUnitaryControlElementTypeEnum.HUMIDISTAT + + +thermostat = IfcUnitaryControlElementTypeEnum.THERMOSTAT + + +weatherstation = IfcUnitaryControlElementTypeEnum.WEATHERSTATION + + +combined = IfcUnitaryControlElementTypeEnum.COMBINED + + +userdefined = IfcUnitaryControlElementTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryControlElementTypeEnum.NOTDEFINED + + +IfcUnitaryEquipmentTypeEnum = enum_namespace() + + +airhandler = IfcUnitaryEquipmentTypeEnum.AIRHANDLER + + +airconditioningunit = IfcUnitaryEquipmentTypeEnum.AIRCONDITIONINGUNIT + + +dehumidifier = IfcUnitaryEquipmentTypeEnum.DEHUMIDIFIER + + +splitsystem = IfcUnitaryEquipmentTypeEnum.SPLITSYSTEM + + +rooftopunit = IfcUnitaryEquipmentTypeEnum.ROOFTOPUNIT + + +userdefined = IfcUnitaryEquipmentTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryEquipmentTypeEnum.NOTDEFINED + + +IfcValveTypeEnum = enum_namespace() + + +airrelease = IfcValveTypeEnum.AIRRELEASE + + +antivacuum = IfcValveTypeEnum.ANTIVACUUM + + +changeover = IfcValveTypeEnum.CHANGEOVER + + +check = IfcValveTypeEnum.CHECK + + +commissioning = IfcValveTypeEnum.COMMISSIONING + + +diverting = IfcValveTypeEnum.DIVERTING + + +drawoffcock = IfcValveTypeEnum.DRAWOFFCOCK + + +doublecheck = IfcValveTypeEnum.DOUBLECHECK + + +doubleregulating = IfcValveTypeEnum.DOUBLEREGULATING + + +faucet = IfcValveTypeEnum.FAUCET + + +flushing = IfcValveTypeEnum.FLUSHING + + +gascock = IfcValveTypeEnum.GASCOCK + + +gastap = IfcValveTypeEnum.GASTAP + + +isolating = IfcValveTypeEnum.ISOLATING + + +mixing = IfcValveTypeEnum.MIXING + + +pressurereducing = IfcValveTypeEnum.PRESSUREREDUCING + + +pressurerelief = IfcValveTypeEnum.PRESSURERELIEF + + +regulating = IfcValveTypeEnum.REGULATING + + +safetycutoff = IfcValveTypeEnum.SAFETYCUTOFF + + +steamtrap = IfcValveTypeEnum.STEAMTRAP + + +stopcock = IfcValveTypeEnum.STOPCOCK + + +userdefined = IfcValveTypeEnum.USERDEFINED + + +notdefined = IfcValveTypeEnum.NOTDEFINED + + +IfcVibrationDamperTypeEnum = enum_namespace() + + +bending_yield = IfcVibrationDamperTypeEnum.BENDING_YIELD + + +shear_yield = IfcVibrationDamperTypeEnum.SHEAR_YIELD + + +axial_yield = IfcVibrationDamperTypeEnum.AXIAL_YIELD + + +friction = IfcVibrationDamperTypeEnum.FRICTION + + +viscous = IfcVibrationDamperTypeEnum.VISCOUS + + +rubber = IfcVibrationDamperTypeEnum.RUBBER + + +userdefined = IfcVibrationDamperTypeEnum.USERDEFINED + + +notdefined = IfcVibrationDamperTypeEnum.NOTDEFINED + + +IfcVibrationIsolatorTypeEnum = enum_namespace() + + +compression = IfcVibrationIsolatorTypeEnum.COMPRESSION + + +spring = IfcVibrationIsolatorTypeEnum.SPRING + + +base = IfcVibrationIsolatorTypeEnum.BASE + + +userdefined = IfcVibrationIsolatorTypeEnum.USERDEFINED + + +notdefined = IfcVibrationIsolatorTypeEnum.NOTDEFINED + + +IfcVoidingFeatureTypeEnum = enum_namespace() + + +cutout = IfcVoidingFeatureTypeEnum.CUTOUT + + +notch = IfcVoidingFeatureTypeEnum.NOTCH + + +hole = IfcVoidingFeatureTypeEnum.HOLE + + +miter = IfcVoidingFeatureTypeEnum.MITER + + +chamfer = IfcVoidingFeatureTypeEnum.CHAMFER + + +edge = IfcVoidingFeatureTypeEnum.EDGE + + +userdefined = IfcVoidingFeatureTypeEnum.USERDEFINED + + +notdefined = IfcVoidingFeatureTypeEnum.NOTDEFINED + + +IfcWallTypeEnum = enum_namespace() + + +movable = IfcWallTypeEnum.MOVABLE + + +parapet = IfcWallTypeEnum.PARAPET + + +partitioning = IfcWallTypeEnum.PARTITIONING + + +plumbingwall = IfcWallTypeEnum.PLUMBINGWALL + + +shear = IfcWallTypeEnum.SHEAR + + +solidwall = IfcWallTypeEnum.SOLIDWALL + + +standard = IfcWallTypeEnum.STANDARD + + +polygonal = IfcWallTypeEnum.POLYGONAL + + +elementedwall = IfcWallTypeEnum.ELEMENTEDWALL + + +retainingwall = IfcWallTypeEnum.RETAININGWALL + + +wavewall = IfcWallTypeEnum.WAVEWALL + + +userdefined = IfcWallTypeEnum.USERDEFINED + + +notdefined = IfcWallTypeEnum.NOTDEFINED + + +IfcWasteTerminalTypeEnum = enum_namespace() + + +floortrap = IfcWasteTerminalTypeEnum.FLOORTRAP + + +floorwaste = IfcWasteTerminalTypeEnum.FLOORWASTE + + +gullysump = IfcWasteTerminalTypeEnum.GULLYSUMP + + +gullytrap = IfcWasteTerminalTypeEnum.GULLYTRAP + + +roofdrain = IfcWasteTerminalTypeEnum.ROOFDRAIN + + +wastedisposalunit = IfcWasteTerminalTypeEnum.WASTEDISPOSALUNIT + + +wastetrap = IfcWasteTerminalTypeEnum.WASTETRAP + + +userdefined = IfcWasteTerminalTypeEnum.USERDEFINED + + +notdefined = IfcWasteTerminalTypeEnum.NOTDEFINED + + +IfcWindowPanelOperationEnum = enum_namespace() + + +sidehungrighthand = IfcWindowPanelOperationEnum.SIDEHUNGRIGHTHAND + + +sidehunglefthand = IfcWindowPanelOperationEnum.SIDEHUNGLEFTHAND + + +tiltandturnrighthand = IfcWindowPanelOperationEnum.TILTANDTURNRIGHTHAND + + +tiltandturnlefthand = IfcWindowPanelOperationEnum.TILTANDTURNLEFTHAND + + +tophung = IfcWindowPanelOperationEnum.TOPHUNG + + +bottomhung = IfcWindowPanelOperationEnum.BOTTOMHUNG + + +pivothorizontal = IfcWindowPanelOperationEnum.PIVOTHORIZONTAL + + +pivotvertical = IfcWindowPanelOperationEnum.PIVOTVERTICAL + + +slidinghorizontal = IfcWindowPanelOperationEnum.SLIDINGHORIZONTAL + + +slidingvertical = IfcWindowPanelOperationEnum.SLIDINGVERTICAL + + +removablecasement = IfcWindowPanelOperationEnum.REMOVABLECASEMENT + + +fixedcasement = IfcWindowPanelOperationEnum.FIXEDCASEMENT + + +otheroperation = IfcWindowPanelOperationEnum.OTHEROPERATION + + +notdefined = IfcWindowPanelOperationEnum.NOTDEFINED + + +IfcWindowPanelPositionEnum = enum_namespace() + + +left = IfcWindowPanelPositionEnum.LEFT + + +middle = IfcWindowPanelPositionEnum.MIDDLE + + +right = IfcWindowPanelPositionEnum.RIGHT + + +bottom = IfcWindowPanelPositionEnum.BOTTOM + + +top = IfcWindowPanelPositionEnum.TOP + + +notdefined = IfcWindowPanelPositionEnum.NOTDEFINED + + +IfcWindowStyleConstructionEnum = enum_namespace() + + +aluminium = IfcWindowStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcWindowStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcWindowStyleConstructionEnum.STEEL + + +wood = IfcWindowStyleConstructionEnum.WOOD + + +aluminium_wood = IfcWindowStyleConstructionEnum.ALUMINIUM_WOOD + + +plastic = IfcWindowStyleConstructionEnum.PLASTIC + + +other_construction = IfcWindowStyleConstructionEnum.OTHER_CONSTRUCTION + + +notdefined = IfcWindowStyleConstructionEnum.NOTDEFINED + + +IfcWindowStyleOperationEnum = enum_namespace() + + +single_panel = IfcWindowStyleOperationEnum.SINGLE_PANEL + + +double_panel_vertical = IfcWindowStyleOperationEnum.DOUBLE_PANEL_VERTICAL + + +double_panel_horizontal = IfcWindowStyleOperationEnum.DOUBLE_PANEL_HORIZONTAL + + +triple_panel_vertical = IfcWindowStyleOperationEnum.TRIPLE_PANEL_VERTICAL + + +triple_panel_bottom = IfcWindowStyleOperationEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_top = IfcWindowStyleOperationEnum.TRIPLE_PANEL_TOP + + +triple_panel_left = IfcWindowStyleOperationEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowStyleOperationEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_horizontal = IfcWindowStyleOperationEnum.TRIPLE_PANEL_HORIZONTAL + + +userdefined = IfcWindowStyleOperationEnum.USERDEFINED + + +notdefined = IfcWindowStyleOperationEnum.NOTDEFINED + + +IfcWindowTypeEnum = enum_namespace() + + +window = IfcWindowTypeEnum.WINDOW + + +skylight = IfcWindowTypeEnum.SKYLIGHT + + +lightdome = IfcWindowTypeEnum.LIGHTDOME + + +userdefined = IfcWindowTypeEnum.USERDEFINED + + +notdefined = IfcWindowTypeEnum.NOTDEFINED + + +IfcWindowTypePartitioningEnum = enum_namespace() + + +single_panel = IfcWindowTypePartitioningEnum.SINGLE_PANEL + + +double_panel_vertical = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_VERTICAL + + +double_panel_horizontal = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_HORIZONTAL + + +triple_panel_vertical = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_VERTICAL + + +triple_panel_bottom = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_top = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_TOP + + +triple_panel_left = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_horizontal = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_HORIZONTAL + + +userdefined = IfcWindowTypePartitioningEnum.USERDEFINED + + +notdefined = IfcWindowTypePartitioningEnum.NOTDEFINED + + +IfcWorkCalendarTypeEnum = enum_namespace() + + +firstshift = IfcWorkCalendarTypeEnum.FIRSTSHIFT + + +secondshift = IfcWorkCalendarTypeEnum.SECONDSHIFT + + +thirdshift = IfcWorkCalendarTypeEnum.THIRDSHIFT + + +userdefined = IfcWorkCalendarTypeEnum.USERDEFINED + + +notdefined = IfcWorkCalendarTypeEnum.NOTDEFINED + + +IfcWorkPlanTypeEnum = enum_namespace() + + +actual = IfcWorkPlanTypeEnum.ACTUAL + + +baseline = IfcWorkPlanTypeEnum.BASELINE + + +planned = IfcWorkPlanTypeEnum.PLANNED + + +userdefined = IfcWorkPlanTypeEnum.USERDEFINED + + +notdefined = IfcWorkPlanTypeEnum.NOTDEFINED + + +IfcWorkScheduleTypeEnum = enum_namespace() + + +actual = IfcWorkScheduleTypeEnum.ACTUAL + + +baseline = IfcWorkScheduleTypeEnum.BASELINE + + +planned = IfcWorkScheduleTypeEnum.PLANNED + + +userdefined = IfcWorkScheduleTypeEnum.USERDEFINED + + +notdefined = IfcWorkScheduleTypeEnum.NOTDEFINED + + +def IfcActionRequest(*args, **kwargs): return ifcopenshell.create_entity('IfcActionRequest', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcActor(*args, **kwargs): return ifcopenshell.create_entity('IfcActor', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcActorRole(*args, **kwargs): return ifcopenshell.create_entity('IfcActorRole', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcActuator(*args, **kwargs): return ifcopenshell.create_entity('IfcActuator', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcActuatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcActuatorType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcAddress', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAdvancedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrep', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAdvancedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrepWithVoids', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAdvancedFace(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedFace', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAirTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminal', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAirTerminalBox(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBox', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAirTerminalBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBoxType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAirTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAirToAirHeatRecovery(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecovery', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAirToAirHeatRecoveryType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecoveryType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAlarm(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarm', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAlarmType(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarmType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAlignment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAlignment2DVerSegCircularArc(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerSegCircularArc', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAlignment2DVerSegLine(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerSegLine', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAlignment2DVerSegParabolicArc(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment2DVerSegParabolicArc', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAlignmentCant(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCant', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAlignmentCantSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCantSegment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAlignmentCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAlignmentHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentHorizontal', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAlignmentHorizontalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentHorizontalSegment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAlignmentParameterSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentParameterSegment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAlignmentSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentSegment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAlignmentVertical(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentVertical', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAlignmentVerticalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentVerticalSegment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAnnotation(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotation', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAnnotationFillArea(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationFillArea', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcApplication(*args, **kwargs): return ifcopenshell.create_entity('IfcApplication', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAppliedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcAppliedValue', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcApproval', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcApprovalRelationship', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcArbitraryClosedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryClosedProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcArbitraryOpenProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryOpenProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcArbitraryProfileDefWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryProfileDefWithVoids', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAsset(*args, **kwargs): return ifcopenshell.create_entity('IfcAsset', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAsymmetricIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcAsymmetricIShapeProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAudioVisualAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualAppliance', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAudioVisualApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualApplianceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAxis1Placement(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis1Placement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAxis2Placement2D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement2D', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAxis2Placement3D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement3D', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAxis2PlacementLinear(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2PlacementLinear', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcAxisLateralInclination(*args, **kwargs): return ifcopenshell.create_entity('IfcAxisLateralInclination', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBSplineCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurveWithKnots', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBSplineSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurface', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurfaceWithKnots', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcBeam', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBeamStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamStandardCase', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBearing(*args, **kwargs): return ifcopenshell.create_entity('IfcBearing', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBearingType(*args, **kwargs): return ifcopenshell.create_entity('IfcBearingType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBlobTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcBlobTexture', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBlock(*args, **kwargs): return ifcopenshell.create_entity('IfcBlock', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBlossCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBlossCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBoiler(*args, **kwargs): return ifcopenshell.create_entity('IfcBoiler', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBoilerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBoilerType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBooleanClippingResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanClippingResult', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBooleanResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanResult', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBorehole(*args, **kwargs): return ifcopenshell.create_entity('IfcBorehole', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBoundaryCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCondition', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBoundaryEdgeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryEdgeCondition', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBoundaryFaceCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryFaceCondition', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBoundaryNodeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeCondition', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBoundaryNodeConditionWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeConditionWarping', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBoundedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedSurface', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBoundingBox(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundingBox', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBoxedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcBoxedHalfSpace', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBridge(*args, **kwargs): return ifcopenshell.create_entity('IfcBridge', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBridgePart(*args, **kwargs): return ifcopenshell.create_entity('IfcBridgePart', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBuilding(*args, **kwargs): return ifcopenshell.create_entity('IfcBuilding', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBuildingElementPart(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPart', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBuildingElementPartType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPartType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBuildingElementProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxy', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBuildingElementProxyType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxyType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBuildingStorey(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingStorey', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBuildingSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingSystem', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBuiltElement(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBuiltElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBuiltSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltSystem', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBurner(*args, **kwargs): return ifcopenshell.create_entity('IfcBurner', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcBurnerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBurnerType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCShapeProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCableCarrierFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFitting', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCableCarrierFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFittingType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCableCarrierSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCableCarrierSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegmentType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCableFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFitting', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCableFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFittingType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCableSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCableSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegmentType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCaissonFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundation', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCaissonFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundationType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCartesianPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPoint', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCartesianPointList(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCartesianPointList2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList2D', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCartesianPointList3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList3D', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCartesianTransformationOperator(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCartesianTransformationOperator2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2D', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCartesianTransformationOperator2DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2DnonUniform', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCartesianTransformationOperator3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3D', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCartesianTransformationOperator3DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3DnonUniform', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCenterLineProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCenterLineProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcChiller(*args, **kwargs): return ifcopenshell.create_entity('IfcChiller', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcChillerType(*args, **kwargs): return ifcopenshell.create_entity('IfcChillerType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcChimney(*args, **kwargs): return ifcopenshell.create_entity('IfcChimney', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcChimneyType(*args, **kwargs): return ifcopenshell.create_entity('IfcChimneyType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCircle(*args, **kwargs): return ifcopenshell.create_entity('IfcCircle', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCircleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleHollowProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCircleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCircularArcSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCircularArcSegment2D', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCivilElement(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCivilElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcClassification', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcClassificationReference(*args, **kwargs): return ifcopenshell.create_entity('IfcClassificationReference', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcClosedShell(*args, **kwargs): return ifcopenshell.create_entity('IfcClosedShell', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcClothoid(*args, **kwargs): return ifcopenshell.create_entity('IfcClothoid', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCoil(*args, **kwargs): return ifcopenshell.create_entity('IfcCoil', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCoilType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoilType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcColourRgb(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgb', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcColourRgbList(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgbList', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcColourSpecification(*args, **kwargs): return ifcopenshell.create_entity('IfcColourSpecification', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcColumn', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcColumnStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnStandardCase', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcColumnType(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsAppliance', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsApplianceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcComplexProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexProperty', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcComplexPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexPropertyTemplate', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCompositeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCompositeCurveOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveOnSurface', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveSegment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCompositeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCompressor(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressor', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCompressorType(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressorType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCondenser(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenser', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCondenserType(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenserType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConic(*args, **kwargs): return ifcopenshell.create_entity('IfcConic', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConnectedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectedFaceSet', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConnectionCurveGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionCurveGeometry', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConnectionGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionGeometry', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConnectionPointEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointEccentricity', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConnectionPointGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointGeometry', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConnectionSurfaceGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionSurfaceGeometry', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConnectionVolumeGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionVolumeGeometry', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcConstraint', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConstructionEquipmentResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResource', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConstructionEquipmentResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResourceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConstructionMaterialResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResource', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConstructionMaterialResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResourceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConstructionProductResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResource', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConstructionProductResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResourceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConstructionResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResource', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConstructionResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResourceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcContext(*args, **kwargs): return ifcopenshell.create_entity('IfcContext', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcContextDependentUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcContextDependentUnit', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcControl(*args, **kwargs): return ifcopenshell.create_entity('IfcControl', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcController(*args, **kwargs): return ifcopenshell.create_entity('IfcController', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcControllerType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConversionBasedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnit', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConversionBasedUnitWithOffset(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnitWithOffset', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConveyorSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcConveyorSegment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcConveyorSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcConveyorSegmentType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCooledBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeam', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCooledBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeamType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCoolingTower(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTower', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCoolingTowerType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTowerType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCoordinateOperation(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateOperation', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCoordinateReferenceSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateReferenceSystem', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCostItem(*args, **kwargs): return ifcopenshell.create_entity('IfcCostItem', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCostSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcCostSchedule', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCostValue(*args, **kwargs): return ifcopenshell.create_entity('IfcCostValue', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCourse(*args, **kwargs): return ifcopenshell.create_entity('IfcCourse', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCourseType(*args, **kwargs): return ifcopenshell.create_entity('IfcCourseType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCovering(*args, **kwargs): return ifcopenshell.create_entity('IfcCovering', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCoveringType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoveringType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCrewResource(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResource', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCrewResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResourceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCsgPrimitive3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgPrimitive3D', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCsgSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgSolid', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCurrencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcCurrencyRelationship', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCurtainWall(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWall', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCurtainWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWallType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCurveBoundedPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedPlane', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCurveBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedSurface', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveSegment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCurveSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveSegment2D', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCurveStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyle', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCurveStyleFont(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFont', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCurveStyleFontAndScaling(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontAndScaling', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCurveStyleFontPattern(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontPattern', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcCylindricalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCylindricalSurface', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcDamper', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcDamperType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDeepFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundation', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDeepFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundationType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDerivedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDerivedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnit', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDerivedUnitElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnitElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDimensionalExponents(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionalExponents', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDirection(*args, **kwargs): return ifcopenshell.create_entity('IfcDirection', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDirectrixCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcDirectrixCurveSweptAreaSolid', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDirectrixDistanceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcDirectrixDistanceSweptAreaSolid', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDiscreteAccessory(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessory', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDiscreteAccessoryType(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessoryType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionBoard', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionBoardType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDistributionChamberElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDistributionChamberElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDistributionCircuit(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionCircuit', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDistributionControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDistributionControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDistributionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDistributionElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDistributionFlowElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDistributionFlowElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDistributionPort(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionPort', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDistributionSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionSystem', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDocumentInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformation', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDocumentInformationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformationRelationship', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDocumentReference(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentReference', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDoor(*args, **kwargs): return ifcopenshell.create_entity('IfcDoor', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDoorLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorLiningProperties', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDoorPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorPanelProperties', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDoorStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorStandardCase', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDoorStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorStyle', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDoorType(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDraughtingPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedColour', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDraughtingPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedCurveFont', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDuctFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFitting', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDuctFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFittingType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDuctSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDuctSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegmentType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDuctSilencer(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencer', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcDuctSilencerType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencerType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEarthworksCut(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksCut', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEarthworksElement(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEarthworksFill(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksFill', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcEdge', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEdgeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEdgeLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeLoop', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElectricAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricAppliance', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElectricApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricApplianceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElectricDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoard', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElectricDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoardType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElectricFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDevice', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElectricFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDeviceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElectricFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowTreatmentDevice', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElectricFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowTreatmentDeviceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElectricGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGenerator', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElectricGeneratorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGeneratorType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElectricMotor(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotor', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElectricMotorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotorType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElectricTimeControl(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControl', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElectricTimeControlType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControlType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElement(*args, **kwargs): return ifcopenshell.create_entity('IfcElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElementAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssembly', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElementAssemblyType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssemblyType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElementComponent(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponent', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElementComponentType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponentType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElementQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcElementQuantity', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcElementarySurface(*args, **kwargs): return ifcopenshell.create_entity('IfcElementarySurface', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEllipse(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipse', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEllipseProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipseProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEnergyConversionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDevice', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEnergyConversionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDeviceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEngine(*args, **kwargs): return ifcopenshell.create_entity('IfcEngine', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEngineType(*args, **kwargs): return ifcopenshell.create_entity('IfcEngineType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEvaporativeCooler(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCooler', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEvaporativeCoolerType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCoolerType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEvaporator(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporator', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEvaporatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporatorType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEvent(*args, **kwargs): return ifcopenshell.create_entity('IfcEvent', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEventTime(*args, **kwargs): return ifcopenshell.create_entity('IfcEventTime', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcEventType(*args, **kwargs): return ifcopenshell.create_entity('IfcEventType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcExtendedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcExtendedProperties', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcExternalInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalInformation', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcExternalReference(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReference', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcExternalReferenceRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReferenceRelationship', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcExternalSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcExternalSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialStructureElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcExternallyDefinedHatchStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedHatchStyle', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcExternallyDefinedSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedSurfaceStyle', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcExternallyDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedTextFont', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcExtrudedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolid', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcExtrudedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolidTapered', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFace(*args, **kwargs): return ifcopenshell.create_entity('IfcFace', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFaceBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBasedSurfaceModel', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFaceBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBound', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFaceOuterBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceOuterBound', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFaceSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceSurface', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFacetedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrep', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFacetedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrepWithVoids', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFacility(*args, **kwargs): return ifcopenshell.create_entity('IfcFacility', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFacilityPart(*args, **kwargs): return ifcopenshell.create_entity('IfcFacilityPart', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFailureConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcFailureConnectionCondition', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFan(*args, **kwargs): return ifcopenshell.create_entity('IfcFan', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFanType(*args, **kwargs): return ifcopenshell.create_entity('IfcFanType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcFastener', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFastenerType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFeatureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFeatureElementAddition(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementAddition', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFeatureElementSubtraction(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementSubtraction', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFillAreaStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyle', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFillAreaStyleHatching(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleHatching', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFillAreaStyleTiles(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleTiles', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFilter(*args, **kwargs): return ifcopenshell.create_entity('IfcFilter', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFilterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFilterType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFireSuppressionTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminal', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFireSuppressionTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminalType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFixedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcFixedReferenceSweptAreaSolid', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowController(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowController', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowControllerType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFitting', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFittingType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowInstrument(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrument', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowInstrumentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrumentType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowMeter(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeter', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowMeterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeterType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowMovingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDevice', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowMovingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDeviceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegmentType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDevice', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDeviceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminal', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminalType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDevice', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDeviceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFooting(*args, **kwargs): return ifcopenshell.create_entity('IfcFooting', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFootingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFootingType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFurnishingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFurnishingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFurniture(*args, **kwargs): return ifcopenshell.create_entity('IfcFurniture', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcFurnitureType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnitureType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGeographicElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGeographicElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGeometricCurveSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricCurveSet', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGeometricRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationContext', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGeometricRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationItem', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGeometricRepresentationSubContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationSubContext', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGeometricSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricSet', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGeomodel(*args, **kwargs): return ifcopenshell.create_entity('IfcGeomodel', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGeoslice(*args, **kwargs): return ifcopenshell.create_entity('IfcGeoslice', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGeotechnicalAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalAssembly', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGeotechnicalElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGeotechnicalStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalStratum', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGradientCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcGradientCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGrid(*args, **kwargs): return ifcopenshell.create_entity('IfcGrid', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGridAxis(*args, **kwargs): return ifcopenshell.create_entity('IfcGridAxis', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGridPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcGridPlacement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcGroup', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcHalfSpaceSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcHalfSpaceSolid', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcHeatExchanger(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchanger', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcHeatExchangerType(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchangerType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcHumidifier(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifier', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcHumidifierType(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifierType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcIShapeProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcImageTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcImageTexture', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcImpactProtectionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcImpactProtectionDevice', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcImpactProtectionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcImpactProtectionDeviceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcInclinedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcInclinedReferenceSweptAreaSolid', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcIndexedColourMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedColourMap', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcIndexedPolyCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolyCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcIndexedPolygonalFace(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFace', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcIndexedPolygonalFaceWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFaceWithVoids', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcIndexedTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTextureMap', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcIndexedTriangleTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTriangleTextureMap', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcInterceptor(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptor', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcInterceptorType(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptorType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcIntersectionCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIntersectionCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcInventory(*args, **kwargs): return ifcopenshell.create_entity('IfcInventory', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcIrregularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeries', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcIrregularTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeriesValue', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcJunctionBox(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBox', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcJunctionBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBoxType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcKerb(*args, **kwargs): return ifcopenshell.create_entity('IfcKerb', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcKerbType(*args, **kwargs): return ifcopenshell.create_entity('IfcKerbType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcLShapeProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLaborResource(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResource', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLaborResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResourceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLagTime(*args, **kwargs): return ifcopenshell.create_entity('IfcLagTime', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLamp(*args, **kwargs): return ifcopenshell.create_entity('IfcLamp', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLampType(*args, **kwargs): return ifcopenshell.create_entity('IfcLampType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLibraryInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryInformation', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLibraryReference(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryReference', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLightDistributionData(*args, **kwargs): return ifcopenshell.create_entity('IfcLightDistributionData', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLightFixture(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixture', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLightFixtureType(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixtureType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLightIntensityDistribution(*args, **kwargs): return ifcopenshell.create_entity('IfcLightIntensityDistribution', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLightSource(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSource', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLightSourceAmbient(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceAmbient', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLightSourceDirectional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceDirectional', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLightSourceGoniometric(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceGoniometric', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLightSourcePositional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourcePositional', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLightSourceSpot(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceSpot', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLine(*args, **kwargs): return ifcopenshell.create_entity('IfcLine', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLineSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcLineSegment2D', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLinearAxisWithInclination(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearAxisWithInclination', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLinearElement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLinearPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPlacement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLinearPlacementWithInclination(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPlacementWithInclination', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLinearPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPositioningElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLinearSpanPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearSpanPlacement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLiquidTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcLiquidTerminal', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLiquidTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcLiquidTerminalType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLocalPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLocalPlacement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcLoop', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcManifoldSolidBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcManifoldSolidBrep', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMapConversion(*args, **kwargs): return ifcopenshell.create_entity('IfcMapConversion', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMappedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcMappedItem', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMarineFacility(*args, **kwargs): return ifcopenshell.create_entity('IfcMarineFacility', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterial', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialClassificationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialClassificationRelationship', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialConstituent(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituent', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialConstituentSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituentSet', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinition', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialDefinitionRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinitionRepresentation', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialLayer(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayer', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialLayerSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSet', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialLayerSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSetUsage', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialLayerWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerWithOffsets', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialList(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialList', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialProfile(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfile', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialProfileSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSet', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialProfileSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsage', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialProfileSetUsageTapering(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsageTapering', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialProfileWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileWithOffsets', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProperties', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialRelationship', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMaterialUsageDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialUsageDefinition', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMeasureWithUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMeasureWithUnit', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMechanicalFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastener', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMechanicalFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastenerType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMedicalDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDevice', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMedicalDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDeviceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMember(*args, **kwargs): return ifcopenshell.create_entity('IfcMember', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMemberStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberStandardCase', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMemberType(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMetric(*args, **kwargs): return ifcopenshell.create_entity('IfcMetric', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMirroredProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcMirroredProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMobileTelecommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcMobileTelecommunicationsAppliance', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMobileTelecommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMobileTelecommunicationsApplianceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMonetaryUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMonetaryUnit', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMooringDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMooringDevice', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMooringDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMooringDeviceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMotorConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnection', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcMotorConnectionType(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnectionType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcNamedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcNamedUnit', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcNavigationElement(*args, **kwargs): return ifcopenshell.create_entity('IfcNavigationElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcNavigationElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcNavigationElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcObject(*args, **kwargs): return ifcopenshell.create_entity('IfcObject', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcObjectDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectDefinition', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcObjectPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectPlacement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcObjective(*args, **kwargs): return ifcopenshell.create_entity('IfcObjective', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOccupant(*args, **kwargs): return ifcopenshell.create_entity('IfcOccupant', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOffsetCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOffsetCurve2D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve2D', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOffsetCurve3D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve3D', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOffsetCurveByDistances(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurveByDistances', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOpenCrossProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenCrossProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOpenShell(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenShell', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOpeningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOpeningStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningStandardCase', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganization', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOrganizationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganizationRelationship', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOrientedEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcOrientedEdge', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOuterBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOuterBoundaryCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOutlet(*args, **kwargs): return ifcopenshell.create_entity('IfcOutlet', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOutletType(*args, **kwargs): return ifcopenshell.create_entity('IfcOutletType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcOwnerHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcOwnerHistory', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcParameterizedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcParameterizedProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPath(*args, **kwargs): return ifcopenshell.create_entity('IfcPath', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPavement(*args, **kwargs): return ifcopenshell.create_entity('IfcPavement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPavementType(*args, **kwargs): return ifcopenshell.create_entity('IfcPavementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPcurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPcurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPerformanceHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcPerformanceHistory', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPermeableCoveringProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPermeableCoveringProperties', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPermit(*args, **kwargs): return ifcopenshell.create_entity('IfcPermit', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPerson(*args, **kwargs): return ifcopenshell.create_entity('IfcPerson', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPersonAndOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcPersonAndOrganization', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPhysicalComplexQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalComplexQuantity', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPhysicalQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalQuantity', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPhysicalSimpleQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalSimpleQuantity', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPile(*args, **kwargs): return ifcopenshell.create_entity('IfcPile', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPileType(*args, **kwargs): return ifcopenshell.create_entity('IfcPileType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPipeFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFitting', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPipeFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFittingType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPipeSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPipeSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegmentType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPixelTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcPixelTexture', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcPlacement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPlanarBox(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarBox', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPlanarExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarExtent', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcPlane', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPlant(*args, **kwargs): return ifcopenshell.create_entity('IfcPlant', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPlate(*args, **kwargs): return ifcopenshell.create_entity('IfcPlate', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPlateStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateStandardCase', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPlateType(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcPoint', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPointByDistanceExpression(*args, **kwargs): return ifcopenshell.create_entity('IfcPointByDistanceExpression', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPointOnCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPointOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnSurface', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPolyLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyLoop', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPolygonalBoundedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalBoundedHalfSpace', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPolygonalFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalFaceSet', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPolyline(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyline', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPort(*args, **kwargs): return ifcopenshell.create_entity('IfcPort', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcPositioningElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPostalAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcPostalAddress', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedColour', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedCurveFont', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPreDefinedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedItem', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPreDefinedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedProperties', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPreDefinedPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedPropertySet', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPreDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedTextFont', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationItem', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPresentationLayerAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerAssignment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPresentationLayerWithStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerWithStyle', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPresentationStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyle', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPresentationStyleAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyleAssignment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProcedure(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedure', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProcedureType(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedureType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcProcess', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcProduct', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProductDefinitionShape(*args, **kwargs): return ifcopenshell.create_entity('IfcProductDefinitionShape', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProductRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcProductRepresentation', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileProperties', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProject(*args, **kwargs): return ifcopenshell.create_entity('IfcProject', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProjectLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectLibrary', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProjectOrder(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectOrder', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProjectedCRS(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectedCRS', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProjectionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectionElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcProperty', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPropertyAbstraction(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyAbstraction', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPropertyBoundedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyBoundedValue', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPropertyDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDefinition', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPropertyDependencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDependencyRelationship', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPropertyEnumeratedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeratedValue', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPropertyEnumeration(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeration', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPropertyListValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyListValue', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPropertyReferenceValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyReferenceValue', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySet', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPropertySetDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetDefinition', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPropertySetTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetTemplate', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPropertySingleValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySingleValue', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPropertyTableValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTableValue', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplate', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPropertyTemplateDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplateDefinition', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProtectiveDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDevice', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnit', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnitType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnitType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProtectiveDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcProxy', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPump(*args, **kwargs): return ifcopenshell.create_entity('IfcPump', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcPumpType(*args, **kwargs): return ifcopenshell.create_entity('IfcPumpType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcQuantityArea(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityArea', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcQuantityCount(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityCount', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcQuantityLength(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityLength', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcQuantitySet(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantitySet', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcQuantityTime(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityTime', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcQuantityVolume(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityVolume', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcQuantityWeight(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityWeight', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRail(*args, **kwargs): return ifcopenshell.create_entity('IfcRail', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRailType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRailing(*args, **kwargs): return ifcopenshell.create_entity('IfcRailing', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRailingType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailingType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRailway(*args, **kwargs): return ifcopenshell.create_entity('IfcRailway', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRamp(*args, **kwargs): return ifcopenshell.create_entity('IfcRamp', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRampFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlight', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRampFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlightType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRampType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRationalBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineCurveWithKnots', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRationalBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineSurfaceWithKnots', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRectangleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleHollowProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRectangularPyramid(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularPyramid', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRectangularTrimmedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularTrimmedSurface', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRecurrencePattern(*args, **kwargs): return ifcopenshell.create_entity('IfcRecurrencePattern', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcReference(*args, **kwargs): return ifcopenshell.create_entity('IfcReference', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcReferent(*args, **kwargs): return ifcopenshell.create_entity('IfcReferent', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRegularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcRegularTimeSeries', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcReinforcedSoil(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcedSoil', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcReinforcementBarProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementBarProperties', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcReinforcementDefinitionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementDefinitionProperties', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcReinforcingBar(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBar', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcReinforcingBarType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBarType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcReinforcingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcReinforcingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcReinforcingMesh(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMesh', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcReinforcingMeshType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMeshType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAggregates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAggregates', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssigns(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssigns', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssignsToActor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToActor', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssignsToControl(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToControl', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssignsToGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroup', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssignsToGroupByFactor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroupByFactor', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssignsToProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProcess', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssignsToProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProduct', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssignsToResource(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToResource', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssociates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociates', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssociatesApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesApproval', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssociatesClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesClassification', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssociatesConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesConstraint', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssociatesDocument(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesDocument', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssociatesLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesLibrary', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssociatesMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesMaterial', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelAssociatesProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelConnects(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnects', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelConnectsElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsElements', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelConnectsPathElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPathElements', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelConnectsPortToElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPortToElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelConnectsPorts(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPorts', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelConnectsStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralActivity', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelConnectsStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralMember', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelConnectsWithEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithEccentricity', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelConnectsWithRealizingElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithRealizingElements', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelContainedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelContainedInSpatialStructure', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelCoversBldgElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversBldgElements', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelCoversSpaces(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversSpaces', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelDeclares(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDeclares', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelDecomposes(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDecomposes', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelDefines(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefines', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelDefinesByObject(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByObject', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelDefinesByProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByProperties', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelDefinesByTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByTemplate', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelDefinesByType(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelFillsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFillsElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelFlowControlElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFlowControlElements', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelInterferesElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelInterferesElements', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelNests(*args, **kwargs): return ifcopenshell.create_entity('IfcRelNests', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelPositions(*args, **kwargs): return ifcopenshell.create_entity('IfcRelPositions', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelProjectsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelProjectsElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelReferencedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelReferencedInSpatialStructure', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelSequence(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSequence', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelServicesBuildings(*args, **kwargs): return ifcopenshell.create_entity('IfcRelServicesBuildings', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelSpaceBoundary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelSpaceBoundary1stLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary1stLevel', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelSpaceBoundary2ndLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary2ndLevel', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelVoidsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelVoidsElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcRelationship', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcReparametrisedCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcReparametrisedCompositeCurveSegment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentation', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationContext', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationItem', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRepresentationMap(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationMap', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcResource(*args, **kwargs): return ifcopenshell.create_entity('IfcResource', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcResourceApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceApprovalRelationship', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcResourceConstraintRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceConstraintRelationship', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcResourceLevelRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceLevelRelationship', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcResourceTime(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceTime', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRevolvedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolid', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRevolvedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolidTapered', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRightCircularCone(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCone', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRightCircularCylinder(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCylinder', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRoad(*args, **kwargs): return ifcopenshell.create_entity('IfcRoad', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRoof(*args, **kwargs): return ifcopenshell.create_entity('IfcRoof', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRoofType(*args, **kwargs): return ifcopenshell.create_entity('IfcRoofType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRoot(*args, **kwargs): return ifcopenshell.create_entity('IfcRoot', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcRoundedRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRoundedRectangleProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSIUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcSIUnit', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSanitaryTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminal', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSanitaryTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminalType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSchedulingTime(*args, **kwargs): return ifcopenshell.create_entity('IfcSchedulingTime', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSeamCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSeamCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSectionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionProperties', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSectionReinforcementProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionReinforcementProperties', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSectionedSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolid', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSectionedSolidHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolidHorizontal', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSectionedSpine(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSpine', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSectionedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSurface', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcSegment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSegmentedReferenceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSegmentedReferenceCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSensor(*args, **kwargs): return ifcopenshell.create_entity('IfcSensor', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSensorType(*args, **kwargs): return ifcopenshell.create_entity('IfcSensorType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSeriesParameterCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSeriesParameterCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcShadingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDevice', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcShadingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDeviceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcShapeAspect(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeAspect', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcShapeModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeModel', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcShapeRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeRepresentation', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcShellBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShellBasedSurfaceModel', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSign(*args, **kwargs): return ifcopenshell.create_entity('IfcSign', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSignType(*args, **kwargs): return ifcopenshell.create_entity('IfcSignType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSignal(*args, **kwargs): return ifcopenshell.create_entity('IfcSignal', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSignalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSignalType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSimpleProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcSimpleProperty', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSimplePropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcSimplePropertyTemplate', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSite(*args, **kwargs): return ifcopenshell.create_entity('IfcSite', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSlab(*args, **kwargs): return ifcopenshell.create_entity('IfcSlab', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSlabElementedCase(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabElementedCase', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSlabStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabStandardCase', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSlabType(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSlippageConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcSlippageConnectionCondition', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSolarDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDevice', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSolarDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDeviceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSolidModel(*args, **kwargs): return ifcopenshell.create_entity('IfcSolidModel', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSolidStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcSolidStratum', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcSpace', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSpaceHeater(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeater', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSpaceHeaterType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeaterType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSpaceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSpatialElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSpatialStructureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSpatialZone(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZone', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSpatialZoneType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZoneType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSphere(*args, **kwargs): return ifcopenshell.create_entity('IfcSphere', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSphericalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSphericalSurface', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStackTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminal', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStackTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminalType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStair(*args, **kwargs): return ifcopenshell.create_entity('IfcStair', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStairFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlight', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStairFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlightType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStairType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAction', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralActivity', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralAnalysisModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAnalysisModel', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnection', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnectionCondition', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralCurveAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveAction', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralCurveConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveConnection', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralCurveMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMember', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralCurveMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMemberVarying', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralCurveReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveReaction', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralItem', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralLinearAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLinearAction', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralLoad(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoad', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralLoadCase(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadCase', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralLoadConfiguration(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadConfiguration', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralLoadGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadGroup', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralLoadLinearForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadLinearForce', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralLoadOrResult(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadOrResult', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralLoadPlanarForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadPlanarForce', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacement(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacementDistortion(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacementDistortion', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralLoadSingleForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForce', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralLoadSingleForceWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForceWarping', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralLoadStatic(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadStatic', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralLoadTemperature(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadTemperature', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralMember', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralPlanarAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPlanarAction', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralPointAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointAction', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralPointConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointConnection', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralPointReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointReaction', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralReaction', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralResultGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralResultGroup', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralSurfaceAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceAction', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralSurfaceConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceConnection', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralSurfaceMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMember', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralSurfaceMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMemberVarying', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStructuralSurfaceReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceReaction', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStyleModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStyleModel', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStyledItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledItem', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcStyledRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledRepresentation', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSubContractResource(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResource', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSubContractResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResourceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSubedge(*args, **kwargs): return ifcopenshell.create_entity('IfcSubedge', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSurface', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSurfaceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSurfaceCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurveSweptAreaSolid', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSurfaceFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceFeature', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSurfaceOfLinearExtrusion(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfLinearExtrusion', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSurfaceOfRevolution(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfRevolution', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSurfaceReinforcementArea(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceReinforcementArea', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyle', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSurfaceStyleLighting(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleLighting', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSurfaceStyleRefraction(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRefraction', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSurfaceStyleRendering(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRendering', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSurfaceStyleShading(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleShading', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSurfaceStyleWithTextures(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleWithTextures', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSurfaceTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceTexture', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptAreaSolid', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSweptDiskSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolid', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSweptDiskSolidPolygonal(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolidPolygonal', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSweptSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptSurface', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSwitchingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDevice', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSwitchingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDeviceType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcSystem', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSystemFurnitureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcSystemFurnitureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTShapeProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTable(*args, **kwargs): return ifcopenshell.create_entity('IfcTable', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTableColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcTableColumn', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTableRow(*args, **kwargs): return ifcopenshell.create_entity('IfcTableRow', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTank(*args, **kwargs): return ifcopenshell.create_entity('IfcTank', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTankType(*args, **kwargs): return ifcopenshell.create_entity('IfcTankType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTask(*args, **kwargs): return ifcopenshell.create_entity('IfcTask', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTaskTime(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTime', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTaskTimeRecurring(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTimeRecurring', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTaskType(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTelecomAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcTelecomAddress', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTendon(*args, **kwargs): return ifcopenshell.create_entity('IfcTendon', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTendonAnchor(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchor', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTendonAnchorType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchorType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTendonConduit(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduit', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTendonConduitType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduitType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTendonType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTessellatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedFaceSet', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTessellatedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedItem', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTextLiteral(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteral', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTextLiteralWithExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteralWithExtent', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTextStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyle', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTextStyleFontModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleFontModel', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTextStyleForDefinedFont(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleForDefinedFont', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTextStyleTextModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleTextModel', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTextureCoordinate(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinate', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTextureCoordinateGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateGenerator', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureMap', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTextureVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertex', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTextureVertexList(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertexList', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTimePeriod(*args, **kwargs): return ifcopenshell.create_entity('IfcTimePeriod', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeries', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeriesValue', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTopologicalRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologicalRepresentationItem', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTopologyRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologyRepresentation', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcToroidalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcToroidalSurface', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTrackElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTrackElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTrackElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTrackElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTransformer(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformer', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTransformerType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformerType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTransitionCurveSegment2D(*args, **kwargs): return ifcopenshell.create_entity('IfcTransitionCurveSegment2D', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTransportElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTransportElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTrapeziumProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTrapeziumProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTriangulatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedFaceSet', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTriangulatedIrregularNetwork(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedIrregularNetwork', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTrimmedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcTrimmedCurve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTubeBundle(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundle', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTubeBundleType(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundleType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTypeObject(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeObject', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTypeProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProcess', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTypeProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProduct', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcTypeResource(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeResource', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcUShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcUShapeProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcUnitAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitAssignment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcUnitaryControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcUnitaryControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElementType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcUnitaryEquipment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipment', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcUnitaryEquipmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipmentType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcValve(*args, **kwargs): return ifcopenshell.create_entity('IfcValve', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcValveType(*args, **kwargs): return ifcopenshell.create_entity('IfcValveType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcVector(*args, **kwargs): return ifcopenshell.create_entity('IfcVector', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcVertex', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcVertexLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexLoop', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcVertexPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexPoint', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcVibrationDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamper', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcVibrationDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamperType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcVibrationIsolator(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolator', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcVibrationIsolatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolatorType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcVirtualElement(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualElement', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcVirtualGridIntersection(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualGridIntersection', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcVoidStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcVoidStratum', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcVoidingFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcVoidingFeature', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWall(*args, **kwargs): return ifcopenshell.create_entity('IfcWall', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWallElementedCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallElementedCase', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWallStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallStandardCase', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcWallType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWasteTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminal', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWasteTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminalType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWaterStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcWaterStratum', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWindow(*args, **kwargs): return ifcopenshell.create_entity('IfcWindow', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWindowLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowLiningProperties', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWindowPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowPanelProperties', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWindowStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowStandardCase', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWindowStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowStyle', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWindowType(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowType', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWorkCalendar(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkCalendar', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWorkControl(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkControl', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWorkPlan(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkPlan', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWorkSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkSchedule', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcWorkTime(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkTime', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcZShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcZShapeProfileDef', 'IFC4X3_RC2', *args, **kwargs) + + +def IfcZone(*args, **kwargs): return ifcopenshell.create_entity('IfcZone', 'IFC4X3_RC2', *args, **kwargs) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcBoxAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcBoxAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['top-left','top-middle','top-right','middle-left','center','middle-right','bottom-left','bottom-middle','bottom-right'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCardinalPointReference_GreaterThanZero: + SCOPE = "type" + TYPE_NAME = "IfcCardinalPointReference" + RULE_NAME = "GreaterThanZero" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCompoundPlaneAngleMeasure_MinutesInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MinutesInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[2 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_SecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "SecondsInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[3 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_MicrosecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MicrosecondsInRange" + + @staticmethod + def __call__(self): + + + assert (sizeof(self) == 3) or ((abs(self[4 - 1])) < 1000000) + + + + +class IfcCompoundPlaneAngleMeasure_ConsistentSign: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "ConsistentSign" + + @staticmethod + def __call__(self): + + + assert (((self[1 - 1]) >= 0) and ((self[2 - 1]) >= 0) and ((self[3 - 1]) >= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) >= 0))) or (((self[1 - 1]) <= 0) and ((self[2 - 1]) <= 0) and ((self[3 - 1]) <= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) <= 0))) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDayInMonthNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInMonthNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 31 + + + + + +class IfcDayInWeekNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInWeekNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 7 + + + + + + + + + + + + + + + + + +class IfcDimensionCount_WR1: + SCOPE = "type" + TYPE_NAME = "IfcDimensionCount" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0 < self <= 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFontStyle_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontStyle" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','italic','oblique'] + + + + + +class IfcFontVariant_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontVariant" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps'] + + + + + +class IfcFontWeight_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontWeight" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps','100','200','300','400','500','600','700','800','900'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcHeatingValueMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcHeatingValueMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMonthInYearNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcMonthInYearNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 12 + + + + + + + + + + + + + + +class IfcNonNegativeLengthMeasure_NotNegative: + SCOPE = "type" + TYPE_NAME = "IfcNonNegativeLengthMeasure" + RULE_NAME = "NotNegative" + + @staticmethod + def __call__(self): + + + assert self >= 0. + + + + + +class IfcNormalisedRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcNormalisedRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPHMeasure_WR21: + SCOPE = "type" + TYPE_NAME = "IfcPHMeasure" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 14.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPositiveInteger_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveInteger" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + +class IfcPositiveLengthMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveLengthMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositivePlaneAngleMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositivePlaneAngleMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositiveRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcSpecularRoughness_WR1: + SCOPE = "type" + TYPE_NAME = "IfcSpecularRoughness" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTextAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['left','right','center','justify'] + + + + + +class IfcTextDecoration_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextDecoration" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['none','underline','overline','line-through','blink'] + + + + + + + + + + + + + + +class IfcTextTransformation_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextTransformation" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['capitalize','uppercase','lowercase','none'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcActorRole_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcActorRole" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + role = self.Role + + assert (role != IfcRoleEnum.USERDEFINED) or ((role == IfcRoleEnum.USERDEFINED) and exists(self.UserDefinedRole)) + + + + + +class IfcActuator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcActuator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcactuatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcActuatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + purpose = self.Purpose + + assert (not exists(purpose)) or ((purpose != IfcAddressTypeEnum.USERDEFINED) or ((purpose == IfcAddressTypeEnum.USERDEFINED) and exists(self.UserDefinedPurpose))) + + + + + +class IfcAdvancedBrep_HasAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrep" + RULE_NAME = "HasAdvancedFaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([afs for afs in self.Outer.CfsFaces if not 'ifc4x3_rc2.ifcadvancedface' in typeof(afs)])) == 0 + + + + + +class IfcAdvancedBrepWithVoids_VoidsHaveAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrepWithVoids" + RULE_NAME = "VoidsHaveAdvancedFaces" + + @staticmethod + def __call__(self): + voids = self.Voids + + assert (sizeof([vsh for vsh in voids if (sizeof([afs for afs in vsh.CfsFaces if not 'ifc4x3_rc2.ifcadvancedface' in typeof(afs)])) == 0])) == 0 + + + + + +class IfcAdvancedFace_ApplicableSurface: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableSurface" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc2.ifcelementarysurface','ifc4x3_rc2.ifcsweptsurface','ifc4x3_rc2.ifcbsplinesurface'] * typeof(self.FaceSurface))) == 1 + + + + +class IfcAdvancedFace_RequiresEdgeCurve: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "RequiresEdgeCurve" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x3_rc2.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not 'ifc4x3_rc2.ifcedgecurve' in typeof(oe.EdgeElement)])) == 0])) == 0 + + + + +class IfcAdvancedFace_ApplicableEdgeCurves: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableEdgeCurves" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x3_rc2.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not (sizeof(['ifc4x3_rc2.ifcline','ifc4x3_rc2.ifcconic','ifc4x3_rc2.ifcpolyline','ifc4x3_rc2.ifcbsplinecurve'] * typeof(oe.EdgeElement.EdgeGeometry))) == 1])) == 0])) == 0 + + + + + +class IfcAirTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcairterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminalBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcairterminalboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirToAirHeatRecovery_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirToAirHeatRecovery_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcairtoairheatrecoverytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirToAirHeatRecoveryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecoveryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAlarm_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAlarm_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcalarmtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAlarmType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarmType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcApproval_HasIdentifierOrName: + SCOPE = "entity" + TYPE_NAME = "IfcApproval" + RULE_NAME = "HasIdentifierOrName" + + @staticmethod + def __call__(self): + identifier = self.Identifier + name = self.Name + + assert exists(identifier) or exists(name) + + + + + + + + +class IfcArbitraryClosedProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert outercurve.Dim == 2 + + + + +class IfcArbitraryClosedProfileDef_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x3_rc2.ifcline' in typeof(outercurve) + + + + +class IfcArbitraryClosedProfileDef_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x3_rc2.ifcoffsetcurve2d' in typeof(outercurve) + + + + + +class IfcArbitraryOpenProfileDef_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_rc2.ifccenterlineprofiledef' in typeof(self)) or (self.ProfileType == IfcProfileTypeEnum.CURVE) + + + + +class IfcArbitraryOpenProfileDef_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + curve = self.Curve + + assert curve.Dim == 2 + + + + + +class IfcArbitraryProfileDefWithVoids_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == area + + + + +class IfcArbitraryProfileDefWithVoids_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if temp.Dim != 2])) == 0 + + + + +class IfcArbitraryProfileDefWithVoids_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if 'ifc4x3_rc2.ifcline' in typeof(temp)])) == 0 + + + + + + + + +class IfcAsymmetricIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + bottomflangethickness = self.BottomFlangeThickness + topflangethickness = self.TopFlangeThickness + + assert (not exists(topflangethickness)) or ((bottomflangethickness + topflangethickness) < overalldepth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + + assert (webthickness < bottomflangewidth) and (webthickness < topflangewidth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidBottomFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidBottomFilletRadius" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + bottomflangefilletradius = self.BottomFlangeFilletRadius + + assert (not exists(bottomflangefilletradius)) or (bottomflangefilletradius <= ((bottomflangewidth - webthickness) / 2.)) + + + + +class IfcAsymmetricIShapeProfileDef_ValidTopFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidTopFilletRadius" + + @staticmethod + def __call__(self): + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + topflangefilletradius = self.TopFlangeFilletRadius + + assert (not exists(topflangefilletradius)) or (topflangefilletradius <= ((topflangewidth - webthickness) / 2.)) + + + + + +class IfcAudioVisualAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAudioVisualAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcaudiovisualappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAudioVisualApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAxis1Placement_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis1Placement_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis1Placement_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc2.ifccartesianpoint' in typeof(self.Location) + + + + +def calc_IfcAxis1Placement_Z(self): + axis = self.Axis + return \ + nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + + + + +class IfcAxis2Placement2D_RefDirIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "RefDirIs2D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 2) + + + + +class IfcAxis2Placement2D_LocationIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIs2D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 2 + + + + +class IfcAxis2Placement2D_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc2.ifccartesianpoint' in typeof(self.Location) + + + + +def calc_IfcAxis2Placement2D_P(self): + refdirection = self.RefDirection + return \ + IfcBuild2Axes(refdirection) + + + + +class IfcAxis2Placement3D_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis2Placement3D_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis2Placement3D_RefDirIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "RefDirIs3D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 3) + + + + +class IfcAxis2Placement3D_AxisToRefDirPosition: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisToRefDirPosition" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + +class IfcAxis2Placement3D_AxisAndRefDirProvision: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisAndRefDirProvision" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert not exists(axis) ^ exists(refdirection) + + + + +class IfcAxis2Placement3D_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc2.ifccartesianpoint' in typeof(self.Location) + + + + +def calc_IfcAxis2Placement3D_P(self): + axis = self.Axis + refdirection = self.RefDirection + return \ + IfcBuildAxes(axis,refdirection) + + + + +class IfcAxis2PlacementLinear_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2PlacementLinear" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc2.ifcpointbydistanceexpression' in typeof(self.Location) + + + + +class IfcAxis2PlacementLinear_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2PlacementLinear" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + + + + + +class IfcBSplineCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + controlpointslist = self.ControlPointsList + + assert (sizeof([temp for temp in controlpointslist if temp.Dim != (controlpointslist[1 - 1].Dim)])) == 0 + + + + +def calc_IfcBSplineCurve_UpperIndexOnControlPoints(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineCurve_ControlPoints(self): + controlpointslist = self.ControlPointsList + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + return \ + IfcListToArray(controlpointslist,0,upperindexoncontrolpoints) + + + + +class IfcBSplineCurveWithKnots_ConsistentBSpline: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "ConsistentBSpline" + + @staticmethod + def __call__(self): + degree = self.Degree + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + knotmultiplicities = self.KnotMultiplicities + knots = self.Knots + upperindexonknots = self.UpperIndexOnKnots + + assert IfcConstraintsParamBSpline(degree,upperindexonknots,upperindexoncontrolpoints,knotmultiplicities,knots) + + + + +class IfcBSplineCurveWithKnots_CorrespondingKnotLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "CorrespondingKnotLists" + + @staticmethod + def __call__(self): + knotmultiplicities = self.KnotMultiplicities + upperindexonknots = self.UpperIndexOnKnots + + assert sizeof(knotmultiplicities) == upperindexonknots + + + + +def calc_IfcBSplineCurveWithKnots_UpperIndexOnKnots(self): + knots = self.Knots + return \ + sizeof(knots) + + + + +def calc_IfcBSplineSurface_UUpper(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineSurface_VUpper(self): + controlpointslist = self.ControlPointsList + return \ + (sizeof(controlpointslist[1 - 1])) - 1 + + + +def calc_IfcBSplineSurface_ControlPoints(self): + controlpointslist = self.ControlPointsList + uupper = self.UUpper + vupper = self.VUpper + return \ + IfcMakeArrayOfArray(controlpointslist,0,uupper,0,vupper) + + + + +class IfcBSplineSurfaceWithKnots_UDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "UDirectionConstraints" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + uknots = self.UKnots + knotuupper = self.KnotUUpper + + assert IfcConstraintsParamBSpline(self.UDegree,knotuupper,self.UUpper,umultiplicities,uknots) + + + + +class IfcBSplineSurfaceWithKnots_VDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "VDirectionConstraints" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + vknots = self.VKnots + knotvupper = self.KnotVUpper + + assert IfcConstraintsParamBSpline(self.VDegree,knotvupper,self.VUpper,vmultiplicities,vknots) + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingULists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingULists" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + knotuupper = self.KnotUUpper + + assert sizeof(umultiplicities) == knotuupper + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingVLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingVLists" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + knotvupper = self.KnotVUpper + + assert sizeof(vmultiplicities) == knotvupper + + + + +def calc_IfcBSplineSurfaceWithKnots_KnotVUpper(self): + vknots = self.VKnots + return \ + sizeof(vknots) + + + +def calc_IfcBSplineSurfaceWithKnots_KnotUUpper(self): + uknots = self.UKnots + return \ + sizeof(uknots) + + + + +class IfcBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBeamStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcBeamStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc2.ifcrelassociates.relatedobjects') if ('ifc4x3_rc2.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc2.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBearing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBearing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcbearingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBearingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBlobTexture_SupportedRasterFormat: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "SupportedRasterFormat" + + @staticmethod + def __call__(self): + + + assert self.RasterFormat in ['bmp','jpg','gif','png'] + + + + +class IfcBlobTexture_RasterCodeByteStream: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "RasterCodeByteStream" + + @staticmethod + def __call__(self): + rastercode = self.RasterCode + + assert (blength(rastercode) % 8) == 0 + + + + + + + + + + + +class IfcBoiler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBoiler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcboilertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBoilerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoilerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBooleanClippingResult_FirstOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "FirstOperandType" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert ('ifc4x3_rc2.ifcsweptareasolid' in typeof(firstoperand)) or ('ifc4x3_rc2.ifcsweptdiscsolid' in typeof(firstoperand)) or ('ifc4x3_rc2.ifcbooleanclippingresult' in typeof(firstoperand)) + + + + +class IfcBooleanClippingResult_SecondOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "SecondOperandType" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert 'ifc4x3_rc2.ifchalfspacesolid' in typeof(secondoperand) + + + + +class IfcBooleanClippingResult_OperatorType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "OperatorType" + + @staticmethod + def __call__(self): + operator = self.Operator + + assert operator == difference + + + + + +class IfcBooleanResult_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + secondoperand = self.SecondOperand + + assert firstoperand.Dim == secondoperand.Dim + + + + +class IfcBooleanResult_FirstOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "FirstOperandClosed" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert (not 'ifc4x3_rc2.ifctessellatedfaceset' in typeof(firstoperand)) or (exists(firstoperand.Closed) and firstoperand.Closed) + + + + +class IfcBooleanResult_SecondOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SecondOperandClosed" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert (not 'ifc4x3_rc2.ifctessellatedfaceset' in typeof(secondoperand)) or (exists(secondoperand.Closed) and secondoperand.Closed) + + + + +def calc_IfcBooleanResult_Dim(self): + firstoperand = self.FirstOperand + return \ + firstoperand.Dim + + + + + + + + + + +class IfcBoundaryCurve_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBoundaryCurve" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + + + assert self.ClosedCurve + + + + + + + + + + + + + + + + + + + + + + + +def calc_IfcBoundingBox_Dim(self): + + return \ + 3 + + + + +class IfcBoxedHalfSpace_UnboundedSurface: + SCOPE = "entity" + TYPE_NAME = "IfcBoxedHalfSpace" + RULE_NAME = "UnboundedSurface" + + @staticmethod + def __call__(self): + + + assert not 'ifc4x3_rc2.ifccurveboundedplane' in typeof(self.BaseSurface) + + + + + + + + + + + + + + +class IfcBuildingElementPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementPart_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcbuildingelementparttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementPartType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPartType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBuildingElementProxy_HasObjectName: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "HasObjectName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcBuildingElementProxy_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementProxy_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcbuildingelementproxytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementProxyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcBuiltElement_MaxOneMaterialAssociation: + SCOPE = "entity" + TYPE_NAME = "IfcBuiltElement" + RULE_NAME = "MaxOneMaterialAssociation" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.HasAssociations if 'ifc4x3_rc2.ifcrelassociatesmaterial' in typeof(temp)])) <= 1 + + + + + + + + +class IfcBuiltSystem_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuiltSystem" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuiltSystemTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuiltSystemTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcBurner_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBurner_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcburnertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBurnerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurnerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCShapeProfileDef_ValidGirth: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidGirth" + + @staticmethod + def __call__(self): + depth = self.Depth + girth = self.Girth + + assert girth < (depth / 2.) + + + + +class IfcCShapeProfileDef_ValidInternalFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidInternalFilletRadius" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + internalfilletradius = self.InternalFilletRadius + + assert (not exists(internalfilletradius)) or ((internalfilletradius <= ((width / 2.) - wallthickness)) and (internalfilletradius <= ((depth / 2.) - wallthickness))) + + + + +class IfcCShapeProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + + assert (wallthickness < (width / 2.)) and (wallthickness < (depth / 2.)) + + + + + +class IfcCableCarrierFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccablecarrierfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableCarrierSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccablecarriersegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccablefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccablesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCaissonFoundation_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCaissonFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccaissonfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCaissonFoundationType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundationType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCartesianPoint_CP2Dor3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianPoint" + RULE_NAME = "CP2Dor3D" + + @staticmethod + def __call__(self): + coordinates = self.Coordinates + + assert hiindex(coordinates) >= 2 + + + + +def calc_IfcCartesianPoint_Dim(self): + coordinates = self.Coordinates + return \ + hiindex(coordinates) + + + + +def calc_IfcCartesianPointList_Dim(self): + + return \ + IfcPointListDim(self) + + + + + + + + + + +class IfcCartesianTransformationOperator_ScaleGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator" + RULE_NAME = "ScaleGreaterZero" + + @staticmethod + def __call__(self): + scl = self.Scl + + assert scl > 0.0 + + + + +def calc_IfcCartesianTransformationOperator_Scl(self): + scale = self.Scale + return \ + nvl(scale,1.0) + + + +def calc_IfcCartesianTransformationOperator_Dim(self): + localorigin = self.LocalOrigin + return \ + localorigin.Dim + + + + +class IfcCartesianTransformationOperator2D_DimEqual2: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "DimEqual2" + + @staticmethod + def __call__(self): + + + assert self.Dim == 2 + + + + +class IfcCartesianTransformationOperator2D_Axis1Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis1Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 2) + + + + +class IfcCartesianTransformationOperator2D_Axis2Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis2Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 2) + + + + +def calc_IfcCartesianTransformationOperator2D_U(self): + + return \ + IfcBaseAxis(2,self.Axis1,self.Axis2,None) + + + + +class IfcCartesianTransformationOperator2DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator2DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + + +class IfcCartesianTransformationOperator3D_DimIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "DimIs3D" + + @staticmethod + def __call__(self): + + + assert self.Dim == 3 + + + + +class IfcCartesianTransformationOperator3D_Axis1Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis1Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis2Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis2Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis3Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis3Is3D" + + @staticmethod + def __call__(self): + axis3 = self.Axis3 + + assert (not exists(axis3)) or (axis3.Dim == 3) + + + + +def calc_IfcCartesianTransformationOperator3D_U(self): + axis3 = self.Axis3 + return \ + IfcBaseAxis(3,self.Axis1,self.Axis2,axis3) + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale3GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale3GreaterZero" + + @staticmethod + def __call__(self): + scl3 = self.Scl3 + + assert scl3 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl3(self): + scale3 = self.Scale3 + return \ + nvl(scale3,self.Scl) + + + + + + + +class IfcChiller_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChiller_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcchillertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChillerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChillerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcChimney_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChimney_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcchimneytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChimneyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimneyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcCircleHollowProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCircleHollowProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert wallthickness < self.Radius + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoil_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccoiltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoilType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoilType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcColumn_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcColumn_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccolumntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcColumnStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcColumnStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc2.ifcrelassociates.relatedobjects') if ('ifc4x3_rc2.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc2.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcColumnType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumnType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcComplexProperty_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert (sizeof([temp for temp in hasproperties if self == temp])) == 0 + + + + +class IfcComplexProperty_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + +class IfcComplexPropertyTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + +class IfcComplexPropertyTemplate_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert (sizeof([temp for temp in haspropertytemplates if self == temp])) == 0 + + + + + +class IfcCompositeCurve_CurveContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "CurveContinuous" + + @staticmethod + def __call__(self): + segments = self.Segments + closedcurve = self.ClosedCurve + + assert ((not closedcurve) and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 1)) or (closedcurve and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 0)) + + + + +class IfcCompositeCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (sizeof([temp for temp in segments if temp.Dim != (segments[1 - 1].Dim)])) == 0 + + + + +def calc_IfcCompositeCurve_NSegments(self): + segments = self.Segments + return \ + sizeof(segments) + + + +def calc_IfcCompositeCurve_ClosedCurve(self): + segments = self.Segments + nsegments = self.NSegments + return \ + (segments[nsegments - 1].Transition) != discontinuous + + + + +class IfcCompositeCurveOnSurface_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveOnSurface" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + + assert sizeof(basissurface) > 0 + + + + +def calc_IfcCompositeCurveOnSurface_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + +class IfcCompositeCurveSegment_ParentIsBoundedCurve: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveSegment" + RULE_NAME = "ParentIsBoundedCurve" + + @staticmethod + def __call__(self): + parentcurve = self.ParentCurve + + assert 'ifc4x3_rc2.ifcboundedcurve' in typeof(parentcurve) + + + + +def calc_IfcCompositeCurveSegment_Dim(self): + parentcurve = self.ParentCurve + return \ + parentcurve.Dim + + + + +class IfcCompositeProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if temp.ProfileType != (profiles[1 - 1].ProfileType)])) == 0 + + + + +class IfcCompositeProfileDef_NoRecursion: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "NoRecursion" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if 'ifc4x3_rc2.ifccompositeprofiledef' in typeof(temp)])) == 0 + + + + + +class IfcCompressor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCompressor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccompressortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCompressorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCondenser_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCondenser_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccondensertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCondenserType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenserType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcConstraint_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcConstraint" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + constraintgrade = self.ConstraintGrade + + assert (constraintgrade != IfcConstraintEnum.USERDEFINED) or ((constraintgrade == IfcConstraintEnum.USERDEFINED) and exists(self.UserDefinedGrade)) + + + + + +class IfcConstructionEquipmentResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionEquipmentResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionMaterialResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionMaterialResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionProductResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionProductResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + + + + + + + + + + + + + +class IfcController_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcController_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccontrollertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcControllerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcControllerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcConveyorSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConveyorSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcConveyorSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcConveyorSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcconveyorsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcConveyorSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConveyorSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcConveyorSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCooledBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCooledBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccooledbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCooledBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCoolingTower_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoolingTower_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccoolingtowertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoolingTowerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTowerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + +class IfcCourse_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCourse" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCourseTypeEnum.USERDEFINED) or ((predefinedtype == IfcCourseTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCourse_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCourse" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccoursetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCourseType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCourseType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCourseTypeEnum.USERDEFINED) or ((predefinedtype == IfcCourseTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCovering_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCovering_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccoveringtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoveringType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoveringType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCrewResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcCrewResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +def calc_IfcCsgPrimitive3D_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcCurtainWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCurtainWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifccurtainwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCurtainWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcCurve_Dim(self): + + return \ + IfcCurveDim(self) + + + + + + + + + + + + + + + + +class IfcCurveStyle_MeasureOfWidth: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "MeasureOfWidth" + + @staticmethod + def __call__(self): + curvewidth = self.CurveWidth + + assert (not exists(curvewidth)) or ('ifc4x3_rc2.ifcpositivelengthmeasure' in typeof(curvewidth)) or (('ifc4x3_rc2.ifcdescriptivemeasure' in typeof(curvewidth)) and (curvewidth == 'bylayer')) + + + + +class IfcCurveStyle_IdentifiableCurveStyle: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "IdentifiableCurveStyle" + + @staticmethod + def __call__(self): + curvefont = self.CurveFont + curvewidth = self.CurveWidth + curvecolour = self.CurveColour + + assert exists(curvefont) or exists(curvewidth) or exists(curvecolour) + + + + + + + + + + + +class IfcCurveStyleFontPattern_VisibleLengthGreaterEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyleFontPattern" + RULE_NAME = "VisibleLengthGreaterEqualZero" + + @staticmethod + def __call__(self): + visiblesegmentlength = self.VisibleSegmentLength + + assert visiblesegmentlength >= 0. + + + + + + + + +class IfcDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDeepFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDeepFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcdeepfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + + + + +class IfcDerivedProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + parentprofile = self.ParentProfile + + assert self.ProfileType == parentprofile.ProfileType + + + + + +class IfcDerivedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof(elements) > 1) or ((sizeof(elements) == 1) and ((elements[1 - 1].Exponent) != 1)) + + + + +class IfcDerivedUnit_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + unittype = self.UnitType + + assert (unittype != IfcDerivedUnitEnum.USERDEFINED) or ((unittype == IfcDerivedUnitEnum.USERDEFINED) and exists(self.UserDefinedType)) + + + + +def calc_IfcDerivedUnit_Dimensions(self): + elements = self.Elements + return \ + IfcDeriveDimensionalExponents(elements) + + + + + + + + + + +class IfcDirection_MagnitudeGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcDirection" + RULE_NAME = "MagnitudeGreaterZero" + + @staticmethod + def __call__(self): + directionratios = self.DirectionRatios + + assert (sizeof([tmp for tmp in directionratios if tmp != 0.0])) > 0 + + + + +def calc_IfcDirection_Dim(self): + directionratios = self.DirectionRatios + return \ + hiindex(directionratios) + + + + +class IfcDirectrixCurveSweptAreaSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcDirectrixCurveSweptAreaSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x3_rc2.ifcconic','ifc4x3_rc2.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + + + + +class IfcDiscreteAccessory_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDiscreteAccessory_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcdiscreteaccessorytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDiscreteAccessoryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessoryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDistributionChamberElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionChamberElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcdistributionchamberelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionChamberElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDocumentReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDocumentReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + name = self.Name + referenceddocument = self.ReferencedDocument + + assert exists(name) ^ exists(referenceddocument) + + + + + +class IfcDoor_CorrectStyleAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectStyleAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcdoortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDoorLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcDoorLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + thresholddepth = self.ThresholdDepth + thresholdthickness = self.ThresholdThickness + + assert not exists(thresholddepth) and (not exists(thresholdthickness)) + + + + +class IfcDoorLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + transomthickness = self.TransomThickness + transomoffset = self.TransomOffset + + assert (exists(transomoffset) and exists(transomthickness)) ^ ((not exists(transomoffset)) and (not exists(transomthickness))) + + + + +class IfcDoorLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + casingthickness = self.CasingThickness + casingdepth = self.CasingDepth + + assert (exists(casingdepth) and exists(casingthickness)) ^ ((not exists(casingdepth)) and (not exists(casingthickness))) + + + + +class IfcDoorLiningProperties_WR35: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR35" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc2.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc2.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcDoorPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc2.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc2.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + + + + + + + +class IfcDoorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDoorTypeEnum.USERDEFINED) or ((predefinedtype == IfcDoorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDraughtingPreDefinedColour_PreDefinedColourNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedColour" + RULE_NAME = "PreDefinedColourNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['black','red','green','blue','yellow','magenta','cyan','white','bylayer'] + + + + + +class IfcDraughtingPreDefinedCurveFont_PreDefinedCurveFontNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedCurveFont" + RULE_NAME = "PreDefinedCurveFontNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['continuous','chain','chaindoubledash','dashed','dotted','bylayer'] + + + + + +class IfcDuctFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcductfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcductsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSilencer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSilencer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcductsilencertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSilencerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEarthworksCut_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEarthworksCut" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEarthworksCutTypeEnum.USERDEFINED) or ((predefinedtype == IfcEarthworksCutTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcEarthworksFill_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEarthworksFill" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEarthworksFillTypeEnum.USERDEFINED) or ((predefinedtype == IfcEarthworksFillTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcEdgeLoop_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + edgelist = self.EdgeList + ne = self.Ne + + assert (edgelist[1 - 1].EdgeStart) == (edgelist[ne - 1].EdgeEnd) + + + + +class IfcEdgeLoop_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcLoopHeadToTail(self) + + + + +def calc_IfcEdgeLoop_Ne(self): + edgelist = self.EdgeList + return \ + sizeof(edgelist) + + + + +class IfcElectricAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcelectricappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcelectricdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowStorageDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowStorageDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcelectricflowstoragedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowStorageDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowTreatmentDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowTreatmentDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcelectricflowtreatmentdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowTreatmentDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricGenerator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricGenerator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcelectricgeneratortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricGeneratorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGeneratorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricMotor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricMotor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcelectricmotortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricMotorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricTimeControl_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricTimeControl_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcelectrictimecontroltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricTimeControlType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControlType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcElementAssembly_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElementAssembly_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcelementassemblytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElementAssemblyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssemblyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcElementQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcElementQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + quantities = self.Quantities + + assert IfcUniqueQuantityNames(quantities) + + + + + + + + + + + + + + + + + + + + + + + +class IfcEngine_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEngine_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcenginetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEngineType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngineType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporativeCooler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporativeCooler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcevaporativecoolertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporativeCoolerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCoolerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcevaporatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvent_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvent_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (not exists(eventtriggertype)) or (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + +class IfcEventType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + +class IfcEventType_CorrectEventTriggerType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectEventTriggerType" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + + + + +class IfcExternalReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcExternalReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + location = self.Location + identification = self.Identification + name = self.Name + + assert exists(identification) or exists(location) or exists(name) + + + + + + + + + + + + + + + + + + + + + + + +class IfcExtrudedAreaSolid_ValidExtrusionDirection: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolid" + RULE_NAME = "ValidExtrusionDirection" + + @staticmethod + def __call__(self): + + + assert IfcDotProduct(IfcDirection(DirectionRatios=[0.0,0.0,1.0]),self.ExtrudedDirection) != 0.0 + + + + + +class IfcExtrudedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + +class IfcFace_HasOuterBound: + SCOPE = "entity" + TYPE_NAME = "IfcFace" + RULE_NAME = "HasOuterBound" + + @staticmethod + def __call__(self): + bounds = self.Bounds + + assert (sizeof([temp for temp in bounds if 'ifc4x3_rc2.ifcfaceouterbound' in typeof(temp)])) <= 1 + + + + + +def calc_IfcFaceBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFan_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcfantype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFanType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFanType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcFeatureElementSubtraction_HasNoSubtraction: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "HasNoSubtraction" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasOpenings) == 0 + + + + +class IfcFeatureElementSubtraction_IsNotFilling: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "IsNotFilling" + + @staticmethod + def __call__(self): + + + assert sizeof(self.FillsVoids) == 0 + + + + + +class IfcFillAreaStyle_MaxOneColour: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneColour" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x3_rc2.ifccolour' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_MaxOneExtHatchStyle: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneExtHatchStyle" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x3_rc2.ifcexternallydefinedhatchstyle' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_ConsistentHatchStyleDef: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "ConsistentHatchStyleDef" + + @staticmethod + def __call__(self): + + + assert IfcCorrectFillAreaStyle(self.FillStyles) + + + + + +class IfcFillAreaStyleHatching_PatternStart2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "PatternStart2D" + + @staticmethod + def __call__(self): + patternstart = self.PatternStart + + assert (not exists(patternstart)) or (patternstart.Dim == 2) + + + + +class IfcFillAreaStyleHatching_RefHatchLine2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "RefHatchLine2D" + + @staticmethod + def __call__(self): + pointofreferencehatchline = self.PointOfReferenceHatchLine + + assert (not exists(pointofreferencehatchline)) or (pointofreferencehatchline.Dim == 2) + + + + + + + + +class IfcFilter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFilter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcfiltertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFilterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFireSuppressionTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFireSuppressionTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcfiresuppressionterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFireSuppressionTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + +class IfcFlowInstrument_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowInstrument_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcflowinstrumenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowInstrumentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrumentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFlowMeter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowMeter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcflowmetertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowMeterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFooting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFooting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcfootingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFootingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFootingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcFurniture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFurniture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcfurnituretype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFurnitureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurnitureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeographicElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcGeographicElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcgeographicelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcGeographicElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeometricCurveSet_NoSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricCurveSet" + RULE_NAME = "NoSurfaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Elements if 'ifc4x3_rc2.ifcsurface' in typeof(temp)])) == 0 + + + + + +class IfcGeometricRepresentationContext_North2D: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationContext" + RULE_NAME = "North2D" + + @staticmethod + def __call__(self): + truenorth = self.TrueNorth + + assert (not exists(truenorth)) or (hiindex(truenorth.DirectionRatios) == 2) + + + + + + + + +class IfcGeometricRepresentationSubContext_ParentNoSub: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "ParentNoSub" + + @staticmethod + def __call__(self): + parentcontext = self.ParentContext + + assert not 'ifc4x3_rc2.ifcgeometricrepresentationsubcontext' in typeof(parentcontext) + + + + +class IfcGeometricRepresentationSubContext_UserTargetProvided: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "UserTargetProvided" + + @staticmethod + def __call__(self): + targetview = self.TargetView + userdefinedtargetview = self.UserDefinedTargetView + + assert (targetview != IfcGeometricProjectionEnum.USERDEFINED) or ((targetview == IfcGeometricProjectionEnum.USERDEFINED) and exists(userdefinedtargetview)) + + + + +class IfcGeometricRepresentationSubContext_NoCoordOperation: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "NoCoordOperation" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasCoordinateOperation) == 0 + + + + +def calc_IfcGeometricRepresentationSubContext_WorldCoordinateSystem(self): + parentcontext = self.ParentContext + return \ + parentcontext.WorldCoordinateSystem + + + +def calc_IfcGeometricRepresentationSubContext_CoordinateSpaceDimension(self): + parentcontext = self.ParentContext + return \ + parentcontext.CoordinateSpaceDimension + + + +def calc_IfcGeometricRepresentationSubContext_TrueNorth(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.TrueNorth,IfcConvertDirectionInto2D(self.WorldCoordinateSystem.P[2 - 1])) + + + +def calc_IfcGeometricRepresentationSubContext_Precision(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.Precision,1) + + + + +class IfcGeometricSet_ConsistentDim: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricSet" + RULE_NAME = "ConsistentDim" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof([temp for temp in elements if temp.Dim != (elements[1 - 1].Dim)])) == 0 + + + + +def calc_IfcGeometricSet_Dim(self): + elements = self.Elements + return \ + elements[1 - 1].Dim + + + + + + + + + + + + + + + + + + + +def calc_IfcGradientCurve_Height(self): + + return \ + IfcGradient(self) + + + + + + + +class IfcGridAxis_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + axiscurve = self.AxisCurve + + assert axiscurve.Dim == 2 + + + + +class IfcGridAxis_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + partofw = self.PartOfW + partofv = self.PartOfV + partofu = self.PartOfU + + assert (sizeof(partofu) == 1) ^ (sizeof(partofv) == 1) ^ (sizeof(partofw) == 1) + + + + + + + + + + + +def calc_IfcHalfSpaceSolid_Dim(self): + + return \ + 3 + + + + +class IfcHeatExchanger_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHeatExchanger_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcheatexchangertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHeatExchangerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchangerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcHumidifier_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHumidifier_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifchumidifiertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHumidifierType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifierType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + flangethickness = self.FlangeThickness + + assert (2. * flangethickness) < overalldepth + + + + +class IfcIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + webthickness = self.WebThickness + + assert webthickness < overallwidth + + + + +class IfcIShapeProfileDef_ValidFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFilletRadius" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + overalldepth = self.OverallDepth + webthickness = self.WebThickness + flangethickness = self.FlangeThickness + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or ((filletradius <= ((overallwidth - webthickness) / 2.)) and (filletradius <= ((overalldepth - (2. * flangethickness)) / 2.))) + + + + + + + + +class IfcImpactProtectionDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcImpactProtectionDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcImpactProtectionDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcimpactprotectiondevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcImpactProtectionDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcImpactProtectionDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcIndexedPolyCurve_Consecutive: + SCOPE = "entity" + TYPE_NAME = "IfcIndexedPolyCurve" + RULE_NAME = "Consecutive" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (not exists(segments)) or IfcConsecutiveSegments(segments) + + + + + + + + + + + + + + + + + +class IfcInterceptor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcInterceptor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcinterceptortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcInterceptorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIntersectionCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + +class IfcIntersectionCurve_DistinctSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "DistinctSurfaces" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) != (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + + + + + + + + + + + +class IfcJunctionBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcJunctionBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcjunctionboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcJunctionBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcLShapeProfileDef_ValidThickness: + SCOPE = "entity" + TYPE_NAME = "IfcLShapeProfileDef" + RULE_NAME = "ValidThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + thickness = self.Thickness + + assert (thickness < depth) and ((not exists(width)) or (thickness < width)) + + + + + +class IfcLaborResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcLaborResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +class IfcLamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifclamptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcLightFixture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLightFixture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifclightfixturetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLightFixtureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixtureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcLine_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcLine" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + pnt = self.Pnt + dir = self.Dir + + assert dir.Dim == pnt.Dim + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcLiquidTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLiquidTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcLiquidTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLiquidTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcliquidterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLiquidTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLiquidTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcLiquidTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcLocalPlacement_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcLocalPlacement" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + placementrelto = self.PlacementRelTo + relativeplacement = self.RelativePlacement + + assert IfcCorrectLocalPlacement(relativeplacement,placementrelto) + + + + + + + + + + + + + + + + + +class IfcMarineFacility_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMarineFacility" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMarineFacilityTypeEnum.USERDEFINED) or ((predefinedtype == IfcMarineFacilityTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + + + + + + + + + + +class IfcMaterialDefinitionRepresentation_OnlyStyledRepresentations: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialDefinitionRepresentation" + RULE_NAME = "OnlyStyledRepresentations" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x3_rc2.ifcstyledrepresentation' in typeof(temp)])) == 0 + + + + + +class IfcMaterialLayer_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialLayer" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + +def calc_IfcMaterialLayerSet_TotalThickness(self): + + return \ + IfcMlsTotalThickness(self) + + + + + + + + + + + + + +class IfcMaterialProfile_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialProfile" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMechanicalFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMechanicalFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcmechanicalfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMechanicalFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMedicalDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMedicalDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcmedicaldevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMedicalDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMember_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMember_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcmembertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMemberStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcMemberStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc2.ifcrelassociates.relatedobjects') if ('ifc4x3_rc2.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc2.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcMemberType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMemberType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcMirroredProfileDef_Operator(self): + + return \ + IfcCartesianTransformationOperator2D(Axis1=IfcDirection(DirectionRatios=[-1.,0.]), Axis2=IfcDirection(DirectionRatios=[0.,1.]), LocalOrigin=IfcCartesianPoint(Coordinates=[0.,0.]), Scale=1.) + + + + +class IfcMobileTelecommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMobileTelecommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcmobiletelecommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMobileTelecommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcMooringDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMooringDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMooringDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMooringDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcmooringdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMooringDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMooringDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMooringDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMotorConnection_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMotorConnection_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcmotorconnectiontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMotorConnectionType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnectionType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcNamedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcNamedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert IfcCorrectDimensions(self.UnitType,self.Dimensions) + + + + + +class IfcNavigationElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcNavigationElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcNavigationElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcNavigationElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcnavigationelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcNavigationElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcNavigationElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcNavigationElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + isdefinedby = self.IsDefinedBy + + assert (sizeof(isdefinedby) == 0) or IfcUniqueDefinitionNames(isdefinedby) + + + + + + + + + + + +class IfcObjective_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcObjective" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + objectivequalifier = self.ObjectiveQualifier + + assert (objectivequalifier != IfcObjectiveEnum.USERDEFINED) or ((objectivequalifier == IfcObjectiveEnum.USERDEFINED) and exists(self.UserDefinedQualifier)) + + + + + +class IfcOccupant_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcOccupant" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not predefinedtype == IfcOccupantTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcOffsetCurve2D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve2D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 2 + + + + + +class IfcOffsetCurve3D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve3D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 3 + + + + + + + + +class IfcOpenCrossProfileDef_CorrectProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrectProfileType" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == IfcProfileTypeEnum.CURVE + + + + +class IfcOpenCrossProfileDef_CorrespondingSlopeWidths: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrespondingSlopeWidths" + + @staticmethod + def __call__(self): + widths = self.Widths + slopes = self.Slopes + + assert sizeof(slopes) == sizeof(widths) + + + + +class IfcOpenCrossProfileDef_CorrespondingTags: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrespondingTags" + + @staticmethod + def __call__(self): + slopes = self.Slopes + tags = self.Tags + + assert (not exists(tags)) or (sizeof(tags) == (sizeof(slopes) + 1)) + + + + + + + + + + + + + + + + + + + + +class IfcOrientedEdge_EdgeElementNotOriented: + SCOPE = "entity" + TYPE_NAME = "IfcOrientedEdge" + RULE_NAME = "EdgeElementNotOriented" + + @staticmethod + def __call__(self): + edgeelement = self.EdgeElement + + assert not 'ifc4x3_rc2.ifcorientededge' in typeof(edgeelement) + + + + +def calc_IfcOrientedEdge_EdgeStart(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeStart,edgeelement.EdgeEnd) + + + +def calc_IfcOrientedEdge_EdgeEnd(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeEnd,edgeelement.EdgeStart) + + + + + + + +class IfcOutlet_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcOutlet_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcoutlettype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcOutletType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutletType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcOwnerHistory_CorrectChangeAction: + SCOPE = "entity" + TYPE_NAME = "IfcOwnerHistory" + RULE_NAME = "CorrectChangeAction" + + @staticmethod + def __call__(self): + changeaction = self.ChangeAction + lastmodifieddate = self.LastModifiedDate + + assert exists(lastmodifieddate) or ((not exists(lastmodifieddate)) and (not exists(changeaction))) or ((not exists(lastmodifieddate)) and exists(changeaction) and ((changeaction == IfcChangeActionEnum.NOTDEFINED) or (changeaction == IfcChangeActionEnum.NOCHANGE))) + + + + + + + + +class IfcPath_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcPath" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcPathHeadToTail(self) + + + + + + + + + + + +class IfcPcurve_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcPcurve" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + referencecurve = self.ReferenceCurve + + assert referencecurve.Dim == 2 + + + + + + + + + + + + + + +class IfcPerson_IdentifiablePerson: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "IdentifiablePerson" + + @staticmethod + def __call__(self): + identification = self.Identification + familyname = self.FamilyName + givenname = self.GivenName + + assert exists(identification) or exists(familyname) or exists(givenname) + + + + +class IfcPerson_ValidSetOfNames: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "ValidSetOfNames" + + @staticmethod + def __call__(self): + familyname = self.FamilyName + givenname = self.GivenName + middlenames = self.MiddleNames + + assert (not exists(middlenames)) or exists(familyname) or exists(givenname) + + + + + + + + +class IfcPhysicalComplexQuantity_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert (sizeof([temp for temp in hasquantities if self == temp])) == 0 + + + + +class IfcPhysicalComplexQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert IfcUniqueQuantityNames(hasquantities) + + + + + + + + + + + +class IfcPile_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPile_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcpiletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPileType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPileType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcpipefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcpipesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPixelTexture_MinPixelInS: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInS" + + @staticmethod + def __call__(self): + width = self.Width + + assert width >= 1 + + + + +class IfcPixelTexture_MinPixelInT: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInT" + + @staticmethod + def __call__(self): + height = self.Height + + assert height >= 1 + + + + +class IfcPixelTexture_NumberOfColours: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "NumberOfColours" + + @staticmethod + def __call__(self): + colourcomponents = self.ColourComponents + + assert 1 <= colourcomponents <= 4 + + + + +class IfcPixelTexture_SizeOfPixelList: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "SizeOfPixelList" + + @staticmethod + def __call__(self): + width = self.Width + height = self.Height + pixel = self.Pixel + + assert sizeof(pixel) == (width * height) + + + + +class IfcPixelTexture_PixelAsByteAndSameLength: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "PixelAsByteAndSameLength" + + @staticmethod + def __call__(self): + pixel = self.Pixel + + assert (sizeof([temp for temp in pixel if ((blength(temp) % 8) == 0) and (blength(temp) == (blength(pixel[1 - 1])))])) == sizeof(pixel) + + + + + +def calc_IfcPlacement_Dim(self): + location = self.Location + return \ + location.Dim + + + + + + + + + + + + + + + + +class IfcPlate_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPlate_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcplatetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPlateStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcPlateStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc2.ifcrelassociates.relatedobjects') if ('ifc4x3_rc2.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc2.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcPlateType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlateType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcPointByDistanceExpression_Dim(self): + basiscurve = self.BasisCurve + return \ + basiscurve.Dim + + + + +def calc_IfcPointOnCurve_Dim(self): + basiscurve = self.BasisCurve + return \ + basiscurve.Dim + + + + +def calc_IfcPointOnSurface_Dim(self): + basissurface = self.BasisSurface + return \ + basissurface.Dim + + + + +class IfcPolyLoop_AllPointsSameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyLoop" + RULE_NAME = "AllPointsSameDim" + + @staticmethod + def __call__(self): + polygon = self.Polygon + + assert (sizeof([temp for temp in polygon if temp.Dim != (polygon[1 - 1].Dim)])) == 0 + + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryDim" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert polygonalboundary.Dim == 2 + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryType: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryType" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert (sizeof(typeof(polygonalboundary) * ['ifc4x3_rc2.ifcpolyline','ifc4x3_rc2.ifccompositecurve'])) == 1 + + + + + + + + +class IfcPolyline_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyline" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + points = self.Points + + assert (sizeof([temp for temp in points if temp.Dim != (points[1 - 1].Dim)])) == 0 + + + + + + + + +class IfcPositioningElement_HasPlacement: + SCOPE = "entity" + TYPE_NAME = "IfcPositioningElement" + RULE_NAME = "HasPlacement" + + @staticmethod + def __call__(self): + + + assert exists(self.ObjectPlacement) + + + + + +class IfcPostalAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPostalAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + internallocation = self.InternalLocation + addresslines = self.AddressLines + postalbox = self.PostalBox + town = self.Town + region = self.Region + postalcode = self.PostalCode + country = self.Country + + assert exists(internallocation) or exists(addresslines) or exists(postalbox) or exists(postalcode) or exists(town) or exists(region) or exists(country) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPresentationLayerAssignment_ApplicableItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerAssignment" + RULE_NAME = "ApplicableItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x3_rc2.ifcshaperepresentation','ifc4x3_rc2.ifcgeometricrepresentationitem','ifc4x3_rc2.ifcmappeditem'])) == 1])) == sizeof(assigneditems) + + + + + +class IfcPresentationLayerWithStyle_ApplicableOnlyToItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerWithStyle" + RULE_NAME = "ApplicableOnlyToItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x3_rc2.ifcgeometricrepresentationitem','ifc4x3_rc2.ifcmappeditem'])) >= 1])) == sizeof(assigneditems) + + + + + + + + + + + +class IfcProcedure_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProcedure_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcProcedureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + + + + +class IfcProduct_PlacementForShapeRepresentation: + SCOPE = "entity" + TYPE_NAME = "IfcProduct" + RULE_NAME = "PlacementForShapeRepresentation" + + @staticmethod + def __call__(self): + objectplacement = self.ObjectPlacement + representation = self.Representation + + assert (exists(representation) and exists(objectplacement)) or (exists(representation) and ((sizeof([temp for temp in representation.Representations if 'ifc4x3_rc2.ifcshaperepresentation' in typeof(temp)])) == 0)) or (not exists(representation)) + + + + + +class IfcProductDefinitionShape_OnlyShapeModel: + SCOPE = "entity" + TYPE_NAME = "IfcProductDefinitionShape" + RULE_NAME = "OnlyShapeModel" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x3_rc2.ifcshapemodel' in typeof(temp)])) == 0 + + + + + + + + + + + + + + +class IfcProject_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProject_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert (not exists(self.RepresentationContexts)) or ((sizeof([temp for temp in self.RepresentationContexts if 'ifc4x3_rc2.ifcgeometricrepresentationsubcontext' in typeof(temp)])) == 0) + + + + +class IfcProject_NoDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "NoDecomposition" + + @staticmethod + def __call__(self): + + + assert sizeof(self.Decomposes) == 0 + + + + + + + + + + + +class IfcProjectedCRS_IsLengthUnit: + SCOPE = "entity" + TYPE_NAME = "IfcProjectedCRS" + RULE_NAME = "IsLengthUnit" + + @staticmethod + def __call__(self): + mapunit = self.MapUnit + + assert (not exists(mapunit)) or (mapunit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + + + + + + + + + + + +class IfcPropertyBoundedValue_SameUnitUpperLower: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperLower" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + lowerboundvalue = self.LowerBoundValue + + assert (not exists(upperboundvalue)) or (not exists(lowerboundvalue)) or (typeof(upperboundvalue) == typeof(lowerboundvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitUpperSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperSet" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(upperboundvalue)) or (not exists(setpointvalue)) or (typeof(upperboundvalue) == typeof(setpointvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitLowerSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitLowerSet" + + @staticmethod + def __call__(self): + lowerboundvalue = self.LowerBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(lowerboundvalue)) or (not exists(setpointvalue)) or (typeof(lowerboundvalue) == typeof(setpointvalue)) + + + + + + + + +class IfcPropertyDependencyRelationship_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyDependencyRelationship" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + dependingproperty = self.DependingProperty + dependantproperty = self.DependantProperty + + assert dependingproperty != dependantproperty + + + + + +class IfcPropertyEnumeratedValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeratedValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + enumerationvalues = self.EnumerationValues + enumerationreference = self.EnumerationReference + + assert (not exists(enumerationreference)) or (not exists(enumerationvalues)) or ((sizeof([temp for temp in enumerationvalues if temp in enumerationreference.EnumerationValues])) == sizeof(enumerationvalues)) + + + + + +class IfcPropertyEnumeration_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeration" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.EnumerationValues if not (typeof(self.EnumerationValues[1 - 1])) == typeof(temp)])) == 0 + + + + + +class IfcPropertyListValue_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyListValue" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.ListValues if not (typeof(self.ListValues[1 - 1])) == typeof(temp)])) == 0 + + + + + + + + +class IfcPropertySet_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySet_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + + + + +class IfcPropertySetTemplate_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySetTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + + + + + +class IfcPropertyTableValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + definedvalues = self.DefinedValues + + assert ((not exists(definingvalues)) and (not exists(definedvalues))) or (sizeof(definingvalues) == sizeof(definedvalues)) + + + + +class IfcPropertyTableValue_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + + assert (not exists(definingvalues)) or ((sizeof([temp for temp in self.DefiningValues if typeof(temp) != (typeof(self.DefiningValues[1 - 1]))])) == 0) + + + + +class IfcPropertyTableValue_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + definedvalues = self.DefinedValues + + assert (not exists(definedvalues)) or ((sizeof([temp for temp in self.DefinedValues if typeof(temp) != (typeof(self.DefinedValues[1 - 1]))])) == 0) + + + + + + + + + + + +class IfcProtectiveDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcprotectivedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcprotectivedevicetrippingunittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProtectiveDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProxy_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcProxy" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcPump_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPump_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcpumptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPumpType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPumpType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcQuantityArea_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.AREAUNIT) + + + + +class IfcQuantityArea_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + areavalue = self.AreaValue + + assert areavalue >= 0. + + + + + +class IfcQuantityCount_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityCount" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + countvalue = self.CountValue + + assert countvalue >= 0. + + + + + +class IfcQuantityLength_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + +class IfcQuantityLength_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + lengthvalue = self.LengthValue + + assert lengthvalue >= 0. + + + + + + + + +class IfcQuantityTime_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.TIMEUNIT) + + + + +class IfcQuantityTime_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + timevalue = self.TimeValue + + assert timevalue >= 0. + + + + + +class IfcQuantityVolume_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.VOLUMEUNIT) + + + + +class IfcQuantityVolume_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + volumevalue = self.VolumeValue + + assert volumevalue >= 0. + + + + + +class IfcQuantityWeight_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.MASSUNIT) + + + + +class IfcQuantityWeight_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + weightvalue = self.WeightValue + + assert weightvalue >= 0. + + + + + +class IfcRail_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRail" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRail_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRail" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcrailtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRailing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRailing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcrailingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcRamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcramptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRampFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcrampflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRationalBSplineCurveWithKnots_SameNumOfWeightsAndPoints: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "SameNumOfWeightsAndPoints" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert sizeof(weightsdata) == sizeof(self.ControlPointsList) + + + + +class IfcRationalBSplineCurveWithKnots_WeightsGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "WeightsGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcCurveWeightsPositive(self) + + + + +def calc_IfcRationalBSplineCurveWithKnots_Weights(self): + weightsdata = self.WeightsData + return \ + IfcListToArray(weightsdata,0,self.UpperIndexOnControlPoints) + + + + +class IfcRationalBSplineSurfaceWithKnots_CorrespondingWeightsDataLists: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingWeightsDataLists" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert (sizeof(weightsdata) == sizeof(self.ControlPointsList)) and ((sizeof(weightsdata[1 - 1])) == (sizeof(self.ControlPointsList[1 - 1]))) + + + + +class IfcRationalBSplineSurfaceWithKnots_WeightValuesGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "WeightValuesGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcSurfaceWeightsPositive(self) + + + + +def calc_IfcRationalBSplineSurfaceWithKnots_Weights(self): + uupper = self.UUpper + vupper = self.VUpper + weightsdata = self.WeightsData + return \ + IfcMakeArrayOfArray(weightsdata,0,uupper,0,vupper) + + + + +class IfcRectangleHollowProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert (wallthickness < (self.XDim / 2.)) and (wallthickness < (self.YDim / 2.)) + + + + +class IfcRectangleHollowProfileDef_ValidInnerRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidInnerRadius" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + innerfilletradius = self.InnerFilletRadius + + assert (not exists(innerfilletradius)) or ((innerfilletradius <= ((self.XDim / 2.) - wallthickness)) and (innerfilletradius <= ((self.YDim / 2.) - wallthickness))) + + + + +class IfcRectangleHollowProfileDef_ValidOuterRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidOuterRadius" + + @staticmethod + def __call__(self): + outerfilletradius = self.OuterFilletRadius + + assert (not exists(outerfilletradius)) or ((outerfilletradius <= (self.XDim / 2.)) and (outerfilletradius <= (self.YDim / 2.))) + + + + + + + + + + + +class IfcRectangularTrimmedSurface_U1AndU2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "U1AndU2Different" + + @staticmethod + def __call__(self): + u1 = self.U1 + u2 = self.U2 + + assert u1 != u2 + + + + +class IfcRectangularTrimmedSurface_V1AndV2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "V1AndV2Different" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + + assert v1 != v2 + + + + +class IfcRectangularTrimmedSurface_UsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "UsenseCompatible" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + u1 = self.U1 + u2 = self.U2 + usense = self.Usense + + assert (('ifc4x3_rc2.ifcelementarysurface' in typeof(basissurface)) and (not 'ifc4x3_rc2.ifcplane' in typeof(basissurface))) or ('ifc4x3_rc2.ifcsurfaceofrevolution' in typeof(basissurface)) or (usense == (u2 > u1)) + + + + +class IfcRectangularTrimmedSurface_VsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "VsenseCompatible" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + vsense = self.Vsense + + assert vsense == (v2 > v1) + + + + + + + + + + + + + + + + + +class IfcReinforcedSoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcedSoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcedSoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcedSoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcReinforcingBar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingBar_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcreinforcingbartype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingBarType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + +class IfcReinforcingBarType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + + + + + + + + +class IfcReinforcingMesh_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingMesh_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcreinforcingmeshtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingMeshType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + +class IfcReinforcingMeshType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + + +class IfcRelAggregates_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAggregates" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelAssigns_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssigns" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatedobjects = self.RelatedObjects + relatedobjectstype = self.RelatedObjectsType + + assert IfcCorrectObjectAssignment(relatedobjectstype,relatedobjects) + + + + + +class IfcRelAssignsToActor_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToActor" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingactor = self.RelatingActor + + assert (sizeof([temp for temp in self.RelatedObjects if relatingactor == temp])) == 0 + + + + + +class IfcRelAssignsToControl_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToControl" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontrol = self.RelatingControl + + assert (sizeof([temp for temp in self.RelatedObjects if relatingcontrol == temp])) == 0 + + + + + +class IfcRelAssignsToGroup_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToGroup" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatinggroup = self.RelatingGroup + + assert (sizeof([temp for temp in self.RelatedObjects if relatinggroup == temp])) == 0 + + + + + + + + +class IfcRelAssignsToProcess_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProcess" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + + assert (sizeof([temp for temp in self.RelatedObjects if relatingprocess == temp])) == 0 + + + + + +class IfcRelAssignsToProduct_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProduct" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingproduct = self.RelatingProduct + + assert (sizeof([temp for temp in self.RelatedObjects if relatingproduct == temp])) == 0 + + + + + +class IfcRelAssignsToResource_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToResource" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingresource = self.RelatingResource + + assert (sizeof([temp for temp in self.RelatedObjects if relatingresource == temp])) == 0 + + + + + + + + + + + + + + + + + + + + + + + +class IfcRelAssociatesMaterial_NoVoidElement: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "NoVoidElement" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if ('ifc4x3_rc2.ifcfeatureelementsubtraction' in typeof(temp)) or ('ifc4x3_rc2.ifcvirtualelement' in typeof(temp))])) == 0 + + + + +class IfcRelAssociatesMaterial_AllowedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "AllowedElements" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if (sizeof(typeof(temp) * ['ifc4x3_rc2.ifcelement','ifc4x3_rc2.ifcelementtype','ifc4x3_rc2.ifcwindowstyle','ifc4x3_rc2.ifcdoorstyle','ifc4x3_rc2.ifcstructuralmember','ifc4x3_rc2.ifcport'])) == 0])) == 0 + + + + + + + + + + + +class IfcRelConnectsElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelConnectsPathElements_NormalizedRelatingPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatingPriorities" + + @staticmethod + def __call__(self): + relatingpriorities = self.RelatingPriorities + + assert (sizeof(relatingpriorities) == 0) or ((sizeof([temp for temp in relatingpriorities if 0 <= temp <= 100])) == sizeof(relatingpriorities)) + + + + +class IfcRelConnectsPathElements_NormalizedRelatedPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatedPriorities" + + @staticmethod + def __call__(self): + relatedpriorities = self.RelatedPriorities + + assert (sizeof(relatedpriorities) == 0) or ((sizeof([temp for temp in relatedpriorities if 0 <= temp <= 100])) == sizeof(relatedpriorities)) + + + + + + + + +class IfcRelConnectsPorts_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPorts" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingport = self.RelatingPort + relatedport = self.RelatedPort + + assert relatingport != relatedport + + + + + + + + + + + + + + + + + +class IfcRelContainedInSpatialStructure_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRelContainedInSpatialStructure" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if 'ifc4x3_rc2.ifcspatialstructureelement' in typeof(temp)])) == 0 + + + + + + + + + + + +class IfcRelDeclares_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelDeclares" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontext = self.RelatingContext + relateddefinitions = self.RelatedDefinitions + + assert (sizeof([temp for temp in relateddefinitions if relatingcontext == temp])) == 0 + + + + + + + + + + + + + + +class IfcRelDefinesByProperties_NoRelatedTypeObject: + SCOPE = "entity" + TYPE_NAME = "IfcRelDefinesByProperties" + RULE_NAME = "NoRelatedTypeObject" + + @staticmethod + def __call__(self): + + + assert (sizeof([types for types in self.RelatedObjects if 'ifc4x3_rc2.ifctypeobject' in typeof(types)])) == 0 + + + + + + + + + + + + + + + + + +class IfcRelInterferesElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelInterferesElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelNests_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelNests" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelPositions_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelPositions" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingpositioningelement = self.RelatingPositioningElement + relatedproducts = self.RelatedProducts + + assert (sizeof([temp for temp in relatedproducts if relatingpositioningelement == temp])) == 0 + + + + + + + + +class IfcRelReferencedInSpatialStructure_AllowedRelatedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelReferencedInSpatialStructure" + RULE_NAME = "AllowedRelatedElements" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if ('ifc4x3_rc2.ifcspatialstructureelement' in typeof(temp)) and (not 'ifc4x3_rc2.ifcspace' in typeof(temp))])) == 0 + + + + + +class IfcRelSequence_AvoidInconsistentSequence: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "AvoidInconsistentSequence" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + relatedprocess = self.RelatedProcess + + assert relatingprocess != relatedprocess + + + + +class IfcRelSequence_CorrectSequenceType: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "CorrectSequenceType" + + @staticmethod + def __call__(self): + sequencetype = self.SequenceType + userdefinedsequencetype = self.UserDefinedSequenceType + + assert (sequencetype != IfcSequenceEnum.USERDEFINED) or ((sequencetype == IfcSequenceEnum.USERDEFINED) and exists(userdefinedsequencetype)) + + + + + + + + +class IfcRelSpaceBoundary_CorrectPhysOrVirt: + SCOPE = "entity" + TYPE_NAME = "IfcRelSpaceBoundary" + RULE_NAME = "CorrectPhysOrVirt" + + @staticmethod + def __call__(self): + relatedbuildingelement = self.RelatedBuildingElement + physicalorvirtualboundary = self.PhysicalOrVirtualBoundary + + assert ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Physical) and (not 'ifc4x3_rc2.ifcvirtualelement' in typeof(relatedbuildingelement))) or ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Virtual) and (('ifc4x3_rc2.ifcvirtualelement' in typeof(relatedbuildingelement)) or ('ifc4x3_rc2.ifcopeningelement' in typeof(relatedbuildingelement)))) or (physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.NotDefined) + + + + + + + + + + + + + + + + + +class IfcReparametrisedCompositeCurveSegment_PositiveLengthParameter: + SCOPE = "entity" + TYPE_NAME = "IfcReparametrisedCompositeCurveSegment" + RULE_NAME = "PositiveLengthParameter" + + @staticmethod + def __call__(self): + paramlength = self.ParamLength + + assert paramlength > 0.0 + + + + + + + + + + + + + + +class IfcRepresentationMap_ApplicableMappedRepr: + SCOPE = "entity" + TYPE_NAME = "IfcRepresentationMap" + RULE_NAME = "ApplicableMappedRepr" + + @staticmethod + def __call__(self): + mappedrepresentation = self.MappedRepresentation + + assert 'ifc4x3_rc2.ifcshapemodel' in typeof(mappedrepresentation) + + + + + + + + + + + + + + + + + + + + +class IfcRevolvedAreaSolid_AxisStartInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisStartInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Location.Coordinates[3 - 1]) == 0.0 + + + + +class IfcRevolvedAreaSolid_AxisDirectionInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisDirectionInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Z.DirectionRatios[3 - 1]) == 0.0 + + + + +def calc_IfcRevolvedAreaSolid_AxisLine(self): + axis = self.Axis + return \ + IfcLine(Pnt=axis.Location, Dir=IfcVector(Orientation=axis.Z, Magnitude=1.0)) + + + + +class IfcRevolvedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + + + + + + + + + + +class IfcRoof_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRoof_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcrooftype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRoofType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoofType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcRoundedRectangleProfileDef_ValidRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRoundedRectangleProfileDef" + RULE_NAME = "ValidRadius" + + @staticmethod + def __call__(self): + roundingradius = self.RoundingRadius + + assert (roundingradius <= (self.XDim / 2.)) and (roundingradius <= (self.YDim / 2.)) + + + + + +def calc_IfcSIUnit_Dimensions(self): + + return \ + IfcDimensionsForSiUnit(self.Name) + + + + +class IfcSanitaryTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSanitaryTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcsanitaryterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSanitaryTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSeamCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + +class IfcSeamCurve_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) == (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + + + + + + + + +class IfcSectionedSolid_DirectrixIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "DirectrixIs3D" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSectionedSolid_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSolid_SectionsSameType: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "SectionsSameType" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (typeof(crosssections[1 - 1])) != typeof(temp)])) == 0 + + + + + +class IfcSectionedSolidHorizontal_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSolidHorizontal_NoLongitudinalOffsets: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "NoLongitudinalOffsets" + + @staticmethod + def __call__(self): + crosssectionpositions = self.CrossSectionPositions + + assert (sizeof([temp for temp in crosssectionpositions if exists(temp.OffsetLongitudinal)])) == 0 + + + + + +class IfcSectionedSpine_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSpine_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSpine_SpineCurveDim: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "SpineCurveDim" + + @staticmethod + def __call__(self): + spinecurve = self.SpineCurve + + assert spinecurve.Dim == 3 + + + + +def calc_IfcSectionedSpine_Dim(self): + + return \ + 3 + + + + + + + + + + + + + +class IfcSensor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSensor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcsensortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSensorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcShadingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcShadingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcshadingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcShadingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcShapeModel_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcShapeModel" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + ofshapeaspect = self.OfShapeAspect + + assert (sizeof(self.OfProductRepresentation) == 1) ^ (sizeof(self.RepresentationMap) == 1) ^ (sizeof(ofshapeaspect) == 1) + + + + + +class IfcShapeRepresentation_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc2.ifcgeometricrepresentationcontext' in typeof(self.ContextOfItems) + + + + +class IfcShapeRepresentation_NoTopologicalItem: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "NoTopologicalItem" + + @staticmethod + def __call__(self): + items = self.Items + + assert (sizeof([temp for temp in items if ('ifc4x3_rc2.ifctopologicalrepresentationitem' in typeof(temp)) and (not (sizeof(['ifc4x3_rc2.ifcvertexpoint','ifc4x3_rc2.ifcedgecurve','ifc4x3_rc2.ifcfacesurface'] * typeof(temp))) == 1)])) == 0 + + + + +class IfcShapeRepresentation_HasRepresentationType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationType" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcShapeRepresentation_HasRepresentationIdentifier: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationIdentifier" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationIdentifier) + + + + +class IfcShapeRepresentation_CorrectItemsForType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectItemsForType" + + @staticmethod + def __call__(self): + + + assert IfcShapeRepresentationTypes(self.RepresentationType,self.Items) + + + + + +def calc_IfcShellBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + +class IfcSign_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSign" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSignTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSign_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSign" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcsigntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSignType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSignTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSignal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSignalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSignal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSignal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcsignaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSignalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSignalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcSlab_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSlab_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcslabtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSlabElementedCase_HasDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcSlabElementedCase" + RULE_NAME = "HasDecomposition" + + @staticmethod + def __call__(self): + + + assert hiindex(self.IsDecomposedBy) > 0 + + + + + +class IfcSlabStandardCase_HasMaterialLayerSetusage: + SCOPE = "entity" + TYPE_NAME = "IfcSlabStandardCase" + RULE_NAME = "HasMaterialLayerSetusage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc2.ifcrelassociates.relatedobjects') if ('ifc4x3_rc2.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc2.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcSlabType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlabType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSolarDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSolarDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcsolardevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSolarDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcSolidModel_Dim(self): + + return \ + 3 + + + + + + + +class IfcSpace_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpace_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcspacetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeater_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpaceHeater_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcspaceheatertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeaterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeaterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSpaceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcSpatialStructureElement_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialStructureElement" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + + + assert (hiindex(self.Decomposes) == 1) and ('ifc4x3_rc2.ifcrelaggregates' in (typeof(self.Decomposes[1 - 1]))) and (('ifc4x3_rc2.ifcproject' in (typeof(self.Decomposes[1 - 1].RelatingObject))) or ('ifc4x3_rc2.ifcspatialstructureelement' in (typeof(self.Decomposes[1 - 1].RelatingObject)))) + + + + + + + + +class IfcSpatialZone_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpatialZone_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcspatialzonetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpatialZoneType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZoneType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcStackTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStackTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcstackterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStackTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStair_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStair_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcstairtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStairFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcstairflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStairType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcStructuralAnalysisModel_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralAnalysisModel" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAnalysisModelTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + + + + +class IfcStructuralCurveAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralCurveAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveAction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert predefinedtype != IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + + + + + + + +class IfcStructuralCurveMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralCurveReaction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveReaction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.SINUS) and (predefinedtype != IfcStructuralCurveActivityTypeEnum.PARABOLA) + + + + + + + + +class IfcStructuralLinearAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc2.ifcstructuralloadlinearforce','ifc4x3_rc2.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + +class IfcStructuralLinearAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralCurveActivityTypeEnum.CONST + + + + + + + + +class IfcStructuralLoadCase_IsLoadCasePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadCase" + RULE_NAME = "IsLoadCasePredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcLoadGroupTypeEnum.LOAD_CASE + + + + + +class IfcStructuralLoadConfiguration_ValidListSize: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadConfiguration" + RULE_NAME = "ValidListSize" + + @staticmethod + def __call__(self): + values = self.Values + locations = self.Locations + + assert (not exists(locations)) or (sizeof(locations) == sizeof(values)) + + + + + +class IfcStructuralLoadGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + actiontype = self.ActionType + actionsource = self.ActionSource + + assert ((predefinedtype != IfcLoadGroupTypeEnum.USERDEFINED) and (actiontype != IfcActionTypeEnum.USERDEFINED) and (actionsource != IfcActionSourceTypeEnum.USERDEFINED)) or exists(self.ObjectType) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcStructuralPlanarAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc2.ifcstructuralloadplanarforce','ifc4x3_rc2.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + +class IfcStructuralPlanarAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralSurfaceActivityTypeEnum.CONST + + + + + +class IfcStructuralPointAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc2.ifcstructuralloadsingleforce','ifc4x3_rc2.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralPointReaction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointReaction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc2.ifcstructuralloadsingleforce','ifc4x3_rc2.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralResultGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralResultGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + theorytype = self.TheoryType + + assert (theorytype != IfcAnalysisTheoryTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcStructuralSurfaceAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralSurfaceAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceReaction_HasPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceReaction" + RULE_NAME = "HasPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStyledItem_ApplicableItem: + SCOPE = "entity" + TYPE_NAME = "IfcStyledItem" + RULE_NAME = "ApplicableItem" + + @staticmethod + def __call__(self): + item = self.Item + + assert not 'ifc4x3_rc2.ifcstyleditem' in typeof(item) + + + + + +class IfcStyledRepresentation_OnlyStyledItems: + SCOPE = "entity" + TYPE_NAME = "IfcStyledRepresentation" + RULE_NAME = "OnlyStyledItems" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x3_rc2.ifcstyleditem' in typeof(temp)])) == 0 + + + + + +class IfcSubContractResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcSubContractResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +def calc_IfcSurface_Dim(self): + + return \ + 3 + + + + +class IfcSurfaceCurve_CurveIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIs3D" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert curve3d.Dim == 3 + + + + +class IfcSurfaceCurve_CurveIsNotPcurve: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIsNotPcurve" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert not 'ifc4x3_rc2.ifcpcurve' in typeof(curve3d) + + + + +def calc_IfcSurfaceCurve_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + + + + +class IfcSurfaceFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSurfaceFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcSurfaceOfLinearExtrusion_DepthGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceOfLinearExtrusion" + RULE_NAME = "DepthGreaterZero" + + @staticmethod + def __call__(self): + depth = self.Depth + + assert depth > 0. + + + + +def calc_IfcSurfaceOfLinearExtrusion_ExtrusionAxis(self): + extrudeddirection = self.ExtrudedDirection + depth = self.Depth + return \ + IfcVector(Orientation=extrudeddirection, Magnitude=depth) + + + + +def calc_IfcSurfaceOfRevolution_AxisLine(self): + axisposition = self.AxisPosition + return \ + IfcLine(Pnt=axisposition.Location, Dir=IfcVector(Orientation=axisposition.Z, Magnitude=1.0)) + + + + +class IfcSurfaceReinforcementArea_SurfaceAndOrShearAreaSpecified: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "SurfaceAndOrShearAreaSpecified" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + surfacereinforcement2 = self.SurfaceReinforcement2 + shearreinforcement = self.ShearReinforcement + + assert exists(surfacereinforcement1) or exists(surfacereinforcement2) or exists(shearreinforcement) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea1: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea1" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + + assert (not exists(surfacereinforcement1)) or (((surfacereinforcement1[1 - 1]) >= 0.) and ((surfacereinforcement1[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement1) == 1) or ((surfacereinforcement1[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea2: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea2" + + @staticmethod + def __call__(self): + surfacereinforcement2 = self.SurfaceReinforcement2 + + assert (not exists(surfacereinforcement2)) or (((surfacereinforcement2[1 - 1]) >= 0.) and ((surfacereinforcement2[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement2) == 1) or ((surfacereinforcement2[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea3: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea3" + + @staticmethod + def __call__(self): + shearreinforcement = self.ShearReinforcement + + assert (not exists(shearreinforcement)) or (shearreinforcement >= 0.) + + + + + +class IfcSurfaceStyle_MaxOneShading: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneShading" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc2.ifcsurfacestyleshading' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneLighting: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneLighting" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc2.ifcsurfacestylelighting' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneRefraction: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneRefraction" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc2.ifcsurfacestylerefraction' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneTextures: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneTextures" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc2.ifcsurfacestylewithtextures' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneExtDefined: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneExtDefined" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc2.ifcexternallydefinedsurfacestyle' in typeof(style)])) <= 1 + + + + + + + + + + + + + + + + + + + + + + + +class IfcSweptAreaSolid_SweptAreaType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptAreaSolid" + RULE_NAME = "SweptAreaType" + + @staticmethod + def __call__(self): + sweptarea = self.SweptArea + + assert sweptarea.ProfileType == IfcProfileTypeEnum.Area + + + + + +class IfcSweptDiskSolid_DirectrixDim: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixDim" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSweptDiskSolid_InnerRadiusSize: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "InnerRadiusSize" + + @staticmethod + def __call__(self): + radius = self.Radius + innerradius = self.InnerRadius + + assert (not exists(innerradius)) or (radius > innerradius) + + + + +class IfcSweptDiskSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x3_rc2.ifcconic','ifc4x3_rc2.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + +class IfcSweptDiskSolidPolygonal_CorrectRadii: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "CorrectRadii" + + @staticmethod + def __call__(self): + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or (filletradius >= self.Radius) + + + + +class IfcSweptDiskSolidPolygonal_DirectrixIsPolyline: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "DirectrixIsPolyline" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_rc2.ifcpolyline' in typeof(self.Directrix)) or (('ifc4x3_rc2.ifcindexedpolycurve' in typeof(self.Directrix)) and (not exists(self.Directrix.Segments))) + + + + + +class IfcSweptSurface_SweptCurveType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptSurface" + RULE_NAME = "SweptCurveType" + + @staticmethod + def __call__(self): + sweptcurve = self.SweptCurve + + assert sweptcurve.ProfileType == IfcProfileTypeEnum.Curve + + + + + +class IfcSwitchingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSwitchingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcswitchingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSwitchingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSystemFurnitureElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSystemFurnitureElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcsystemfurnitureelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSystemFurnitureElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < depth + + + + +class IfcTShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcTable_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + rows = self.Rows + + assert (sizeof([temp for temp in rows if hiindex(temp.RowCells) != (hiindex(rows[1 - 1].RowCells))])) == 0 + + + + +class IfcTable_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + numberofheadings = self.NumberOfHeadings + + assert 0 <= numberofheadings <= 1 + + + + +def calc_IfcTable_NumberOfCellsInRow(self): + rows = self.Rows + return \ + hiindex(rows[1 - 1].RowCells) + + + +def calc_IfcTable_NumberOfHeadings(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if temp.IsHeading]) + + + +def calc_IfcTable_NumberOfDataRows(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if not temp.IsHeading]) + + + + + + + + + + +class IfcTank_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTank_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifctanktype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTankType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTankType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTask_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTask_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcTaskType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTaskType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + +class IfcTelecomAddress_MinimumDataProvided: + SCOPE = "entity" + TYPE_NAME = "IfcTelecomAddress" + RULE_NAME = "MinimumDataProvided" + + @staticmethod + def __call__(self): + telephonenumbers = self.TelephoneNumbers + facsimilenumbers = self.FacsimileNumbers + pagernumber = self.PagerNumber + electronicmailaddresses = self.ElectronicMailAddresses + wwwhomepageurl = self.WWWHomePageURL + messagingids = self.MessagingIDs + + assert exists(telephonenumbers) or exists(facsimilenumbers) or exists(pagernumber) or exists(electronicmailaddresses) or exists(wwwhomepageurl) or exists(messagingids) + + + + + +class IfcTendon_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendon_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifctendontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonAnchor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifctendonanchortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonConduit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonConduit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifctendonconduittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonConduitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcTessellatedFaceSet_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcTextLiteralWithExtent_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcTextLiteralWithExtent" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + extent = self.Extent + + assert not 'ifc4x3_rc2.ifcplanarbox' in typeof(extent) + + + + + + + + +class IfcTextStyleFontModel_MeasureOfFontSize: + SCOPE = "entity" + TYPE_NAME = "IfcTextStyleFontModel" + RULE_NAME = "MeasureOfFontSize" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_rc2.ifclengthmeasure' in typeof(self.FontSize)) and (self.FontSize > 0.) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTopologyRepresentation_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x3_rc2.ifctopologicalrepresentationitem' in typeof(temp)])) == 0 + + + + +class IfcTopologyRepresentation_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcTopologyRepresentation_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + + + assert IfcTopologyRepresentationTypes(self.RepresentationType,self.Items) + + + + + +class IfcToroidalSurface_MajorLargerMinor: + SCOPE = "entity" + TYPE_NAME = "IfcToroidalSurface" + RULE_NAME = "MajorLargerMinor" + + @staticmethod + def __call__(self): + majorradius = self.MajorRadius + minorradius = self.MinorRadius + + assert minorradius < majorradius + + + + + +class IfcTrackElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTrackElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTrackElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTrackElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifctrackelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTrackElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTrackElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTrackElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTransformer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransformer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifctranformertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransformerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcTransportElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or ((predefinedtype != IfcTransportElementFixedTypeEnum.USERDEFINED) and (predefinedtype != IfcTransportElementNonFixedTypeEnum.USERDEFINED)) or (((predefinedtype == IfcTransportElementFixedTypeEnum.USERDEFINED) or (predefinedtype == IfcTransportElementNonFixedTypeEnum.USERDEFINED)) and exists(self.ObjectType)) + + + + +class IfcTransportElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifctransportelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransportElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert ((predefinedtype != IfcTransportElementFixedTypeEnum.USERDEFINED) and (predefinedtype != IfcTransportElementNonFixedTypeEnum.USERDEFINED)) or (((predefinedtype == IfcTransportElementFixedTypeEnum.USERDEFINED) or (predefinedtype == IfcTransportElementNonFixedTypeEnum.USERDEFINED)) and exists(self.ElementType)) + + + + + + + + +def calc_IfcTriangulatedFaceSet_NumberOfTriangles(self): + coordindex = self.CoordIndex + return \ + sizeof(coordindex) + + + + +class IfcTriangulatedIrregularNetwork_NotClosed: + SCOPE = "entity" + TYPE_NAME = "IfcTriangulatedIrregularNetwork" + RULE_NAME = "NotClosed" + + @staticmethod + def __call__(self): + + + assert self.Closed == False + + + + + +class IfcTrimmedCurve_Trim1ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim1ValuesConsistent" + + @staticmethod + def __call__(self): + trim1 = self.Trim1 + + assert (hiindex(trim1) == 1) or ((typeof(trim1[1 - 1])) != (typeof(trim1[2 - 1]))) + + + + +class IfcTrimmedCurve_Trim2ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim2ValuesConsistent" + + @staticmethod + def __call__(self): + trim2 = self.Trim2 + + assert (hiindex(trim2) == 1) or ((typeof(trim2[1 - 1])) != (typeof(trim2[2 - 1]))) + + + + +class IfcTrimmedCurve_NoTrimOfBoundedCurves: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "NoTrimOfBoundedCurves" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert not 'ifc4x3_rc2.ifcboundedcurve' in typeof(basiscurve) + + + + + +class IfcTubeBundle_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTubeBundle_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifctubebundletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTubeBundleType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundleType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTypeObject_NameRequired: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "NameRequired" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTypeObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + haspropertysets = self.HasPropertySets + + assert (not exists(haspropertysets)) or IfcUniquePropertySetNames(haspropertysets) + + + + + + + + +class IfcTypeProduct_ApplicableOccurrence: + SCOPE = "entity" + TYPE_NAME = "IfcTypeProduct" + RULE_NAME = "ApplicableOccurrence" + + @staticmethod + def __call__(self): + + + assert (not exists(lambda: self.Types[1 - 1])) or ((sizeof([temp for temp in self.Types[1 - 1].RelatedObjects if not 'ifc4x3_rc2.ifcproduct' in typeof(temp)])) == 0) + + + + + + + + +class IfcUShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + +class IfcUShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcUnitAssignment_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcUnitAssignment" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + units = self.Units + + assert IfcCorrectUnitAssignment(units) + + + + + +class IfcUnitaryControlElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryControlElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcunitarycontrolelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryControlElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcUnitaryEquipment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryEquipment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcunitaryequipmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryEquipmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcValve_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcValve_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcvalvetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcValveType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValveType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVector_MagGreaterOrEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcVector" + RULE_NAME = "MagGreaterOrEqualZero" + + @staticmethod + def __call__(self): + magnitude = self.Magnitude + + assert magnitude >= 0.0 + + + + +def calc_IfcVector_Dim(self): + orientation = self.Orientation + return \ + orientation.Dim + + + + + + + + + + + + + +class IfcVibrationDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcvibrationdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVibrationIsolator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationIsolator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcvibrationisolatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationIsolatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcVoidingFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcVoidingFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVoidingFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWallElementedCase_HasDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcWallElementedCase" + RULE_NAME = "HasDecomposition" + + @staticmethod + def __call__(self): + + + assert hiindex(self.IsDecomposedBy) > 0 + + + + + +class IfcWallStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcWallStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc2.ifcrelassociates.relatedobjects') if ('ifc4x3_rc2.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc2.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWasteTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWasteTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcwasteterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWasteTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcWindow_CorrectStyleAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectStyleAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc2.ifcwindowtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWindowLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcWindowLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + firsttransomoffset = self.FirstTransomOffset + secondtransomoffset = self.SecondTransomOffset + + assert not (not exists(firsttransomoffset)) and exists(secondtransomoffset) + + + + +class IfcWindowLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + firstmullionoffset = self.FirstMullionOffset + secondmullionoffset = self.SecondMullionOffset + + assert not (not exists(firstmullionoffset)) and exists(secondmullionoffset) + + + + +class IfcWindowLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc2.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc2.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcWindowPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc2.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc2.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + + + + + + + +class IfcWindowType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWindowTypeEnum.USERDEFINED) or ((predefinedtype == IfcWindowTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWorkCalendar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkCalendar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkCalendarTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkCalendarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcWorkPlan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkPlan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkPlanTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkPlanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcWorkSchedule_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkSchedule" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkScheduleTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkScheduleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcZShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcZShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + + +class IfcZone_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcZone" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof(self.IsGroupedBy) == 0) or ((sizeof([temp for temp in self.IsGroupedBy[1 - 1].RelatedObjects if not ('ifc4x3_rc2.ifczone' in typeof(temp)) or ('ifc4x3_rc2.ifcspace' in typeof(temp)) or ('ifc4x3_rc2.ifcspatialzone' in typeof(temp))])) == 0) + + + + + +class IfcRepresentationContextSameWCS: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcGeometricRepresentationContext = file.by_type("IfcGeometricRepresentationContext") + isdifferent = False + if sizeof(IfcGeometricRepresentationContext) > 1: + for i in range(2, hiindex(IfcGeometricRepresentationContext) + 1): + if (IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem) != (IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem): + isdifferent = (not IfcSameValidPrecision(IfcGeometricRepresentationContext[1 - 1].Precision,IfcGeometricRepresentationContext[i - 1].Precision)) or (not IfcSameAxis2Placement(IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[1 - 1].Precision)) + if isdifferent == True: + break + + assert isdifferent == False + + + + + +class IfcSingleProjectInstance: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcProject = file.by_type("IfcProject") + + + + assert sizeof(IfcProject) <= 1 + + + + +def IfcAssociatedSurface(arg): + + surf = arg.BasisSurface + return surf + + +def IfcBaseAxis(dim, axis1, axis2, axis3): + + + + if dim == 3: + d1 = nvl(IfcNormalise(axis3),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,axis1) + u = [d2,IfcSecondProjAxis(d1,d2,axis2),d1] + else: + if exists(axis1): + d1 = IfcNormalise(axis1) + u = [d1,IfcOrthogonalComplement(d1)] + if exists(axis2): + factor = IfcDotProduct(axis2,u[2 - 1]) + if factor < 0.0: + u[2 - 1].DirectionRatios[1 - 1] = -u[2 - 1].DirectionRatios[1 - 1] + u[2 - 1].DirectionRatios[2 - 1] = -u[2 - 1].DirectionRatios[2 - 1] + else: + if exists(axis2): + d1 = IfcNormalise(axis2) + u = [IfcOrthogonalComplement(d1),d1] + u[1 - 1].DirectionRatios[1 - 1] = -u[1 - 1].DirectionRatios[1 - 1] + u[1 - 1].DirectionRatios[2 - 1] = -u[1 - 1].DirectionRatios[2 - 1] + else: + u = [IfcDirection(DirectionRatios=[1.0,0.0]),IfcDirection(DirectionRatios=[0.0,1.0])] + return u + + +def IfcBooleanChoose(b, choice1, choice2): + + if b: + return choice1 + else: + return choice2 + + +def IfcBuild2Axes(refdirection): + d = nvl(IfcNormalise(refdirection),IfcDirection(DirectionRatios=[1.0,0.0])) + return [d,IfcOrthogonalComplement(d)] + + +def IfcBuildAxes(axis, refdirection): + + d1 = nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,refdirection) + return [d2,IfcNormalise(IfcCrossProduct(d1,d2)).Orientation,d1] + + +def IfcConsecutiveSegments(segments): + result = True + for i in range(1, hiindex(segments) - 1 + 1): + if (segments[i - 1][hiindex(segments[i - 1]) - 1]) != (segments[i - 1][1 - 1]): + result = False + break + return result + + +def IfcConstraintsParamBSpline(degree, upknots, upcp, knotmult, knots): + result = True + + sum = knotmult[1 - 1] + for i in range(2, upknots + 1): + sum = sum + (knotmult[i - 1]) + if (degree < 1) or (upknots < 2) or (upcp < degree) or (sum != (degree + upcp + 2)): + result = False + return result + k = knotmult[1 - 1] + if (k < 1) or (k > (degree + 1)): + result = False + return result + for i in range(2, upknots + 1): + if ((knotmult[i - 1]) < 1) or ((knots[i - 1]) <= (knots[i - 1])): + result = False + return result + k = knotmult[i - 1] + if (i < upknots) and (k > degree): + result = False + return result + if (i == upknots) and (k > (degree + 1)): + result = False + return result + return result + + +def IfcConvertDirectionInto2D(direction): + direction2d = IfcDirection(DirectionRatios=[0.,1.]) + temp = list(direction2d.DirectionRatios) + temp[1 - 1] = direction.DirectionRatios[1 - 1] + direction2d.DirectionRatios = temp + temp = list(direction2d.DirectionRatios) + temp[2 - 1] = direction.DirectionRatios[2 - 1] + direction2d.DirectionRatios = temp + return direction2d + + +def IfcCorrectDimensions(m, dim): + + if m == lengthunit: + if dim == IfcDimensionalExponents(1,0,0,0,0,0,0): + return True + else: + return False + elif m == massunit: + if dim == IfcDimensionalExponents(0,1,0,0,0,0,0): + return True + else: + return False + elif m == timeunit: + if dim == IfcDimensionalExponents(0,0,1,0,0,0,0): + return True + else: + return False + elif m == electriccurrentunit: + if dim == IfcDimensionalExponents(0,0,0,1,0,0,0): + return True + else: + return False + elif m == thermodynamictemperatureunit: + if dim == IfcDimensionalExponents(0,0,0,0,1,0,0): + return True + else: + return False + elif m == amountofsubstanceunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,1,0): + return True + else: + return False + elif m == luminousintensityunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == planeangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == solidangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == areaunit: + if dim == IfcDimensionalExponents(2,0,0,0,0,0,0): + return True + else: + return False + elif m == volumeunit: + if dim == IfcDimensionalExponents(3,0,0,0,0,0,0): + return True + else: + return False + elif m == absorbeddoseunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == radioactivityunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == electriccapacitanceunit: + if dim == IfcDimensionalExponents(-2,-1,4,2,0,0,0): + return True + else: + return False + elif m == doseequivalentunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == electricchargeunit: + if dim == IfcDimensionalExponents(0,0,1,1,0,0,0): + return True + else: + return False + elif m == electricconductanceunit: + if dim == IfcDimensionalExponents(-2,-1,3,2,0,0,0): + return True + else: + return False + elif m == electricvoltageunit: + if dim == IfcDimensionalExponents(2,1,-3,-1,0,0,0): + return True + else: + return False + elif m == electricresistanceunit: + if dim == IfcDimensionalExponents(2,1,-3,-2,0,0,0): + return True + else: + return False + elif m == energyunit: + if dim == IfcDimensionalExponents(2,1,-2,0,0,0,0): + return True + else: + return False + elif m == forceunit: + if dim == IfcDimensionalExponents(1,1,-2,0,0,0,0): + return True + else: + return False + elif m == frequencyunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == inductanceunit: + if dim == IfcDimensionalExponents(2,1,-2,-2,0,0,0): + return True + else: + return False + elif m == illuminanceunit: + if dim == IfcDimensionalExponents(-2,0,0,0,0,0,1): + return True + else: + return False + elif m == luminousfluxunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == magneticfluxunit: + if dim == IfcDimensionalExponents(2,1,-2,-1,0,0,0): + return True + else: + return False + elif m == magneticfluxdensityunit: + if dim == IfcDimensionalExponents(0,1,-2,-1,0,0,0): + return True + else: + return False + elif m == powerunit: + if dim == IfcDimensionalExponents(2,1,-3,0,0,0,0): + return True + else: + return False + elif m == pressureunit: + if dim == IfcDimensionalExponents(-1,1,-2,0,0,0,0): + return True + else: + return False + else: + return unknown + + +def IfcCorrectFillAreaStyle(styles): + hatching = 0 + tiles = 0 + colour = 0 + external = 0 + external = sizeof([style for style in styles if 'ifc4x3_rc2.ifcexternallydefinedhatchstyle' in typeof(style)]) + hatching = sizeof([style for style in styles if 'ifc4x3_rc2.ifcfillareastylehatching' in typeof(style)]) + tiles = sizeof([style for style in styles if 'ifc4x3_rc2.ifcfillareastyletiles' in typeof(style)]) + colour = sizeof([style for style in styles if 'ifc4x3_rc2.ifccolour' in typeof(style)]) + if external > 1: + return False + if (external == 1) and ((hatching > 0) or (tiles > 0) or (colour > 0)): + return False + if colour > 1: + return False + if (hatching > 0) and (tiles > 0): + return False + return True + + +def IfcCorrectLocalPlacement(axisplacement, relplacement): + + if exists(relplacement): + if 'ifc4x3_rc2.ifcgridplacement' in typeof(relplacement): + return None + if 'ifc4x3_rc2.ifclocalplacement' in typeof(relplacement): + if 'ifc4x3_rc2.ifcaxis2placement2d' in typeof(axisplacement): + return True + if 'ifc4x3_rc2.ifcaxis2placement3d' in typeof(axisplacement): + if relplacement.RelativePlacement.Dim == 3: + return True + else: + return False + return True + return None + + +def IfcCorrectObjectAssignment(constraint, objects): + count = 0 + if not exists(constraint): + return True + if constraint == IfcObjectTypeEnum.NOTDEFINED: + return True + elif constraint == IfcObjectTypeEnum.PRODUCT: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc2.ifcproduct' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROCESS: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc2.ifcprocess' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.CONTROL: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc2.ifccontrol' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.RESOURCE: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc2.ifcresource' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.ACTOR: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc2.ifcactor' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.GROUP: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc2.ifcgroup' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROJECT: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc2.ifcproject' in typeof(temp)]) + return count == 0 + else: + return None + + +def IfcCorrectUnitAssignment(units): + namedunitnumber = 0 + derivedunitnumber = 0 + monetaryunitnumber = 0 + namedunitnames = express_set([]) + derivedunitnames = express_set([]) + namedunitnumber = sizeof([temp for temp in units if ('ifc4x3_rc2.ifcnamedunit' in typeof(temp)) and (not temp.UnitType == IfcUnitEnum.USERDEFINED)]) + derivedunitnumber = sizeof([temp for temp in units if ('ifc4x3_rc2.ifcderivedunit' in typeof(temp)) and (not temp.UnitType == IfcDerivedUnitEnum.USERDEFINED)]) + monetaryunitnumber = sizeof([temp for temp in units if 'ifc4x3_rc2.ifcmonetaryunit' in typeof(temp)]) + for i in range(1, sizeof(units) + 1): + if ('ifc4x3_rc2.ifcnamedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcUnitEnum.USERDEFINED): + namedunitnames = namedunitnames + (units[i - 1].UnitType) + if ('ifc4x3_rc2.ifcderivedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcDerivedUnitEnum.USERDEFINED): + derivedunitnames = derivedunitnames + (units[i - 1].UnitType) + return (sizeof(namedunitnames) == namedunitnumber) and (sizeof(derivedunitnames) == derivedunitnumber) and (monetaryunitnumber <= 1) + + +def IfcCrossProduct(arg1, arg2): + + + + + if ((not exists(arg1)) or (arg1.Dim == 2)) or ((not exists(arg2)) or (arg2.Dim == 2)): + return None + else: + v1 = IfcNormalise(arg1).DirectionRatios + v2 = IfcNormalise(arg2).DirectionRatios + res = IfcDirection(DirectionRatios=[((v1[2 - 1]) * (v2[3 - 1])) - ((v1[3 - 1]) * (v2[2 - 1])),((v1[3 - 1]) * (v2[1 - 1])) - ((v1[1 - 1]) * (v2[3 - 1])),((v1[1 - 1]) * (v2[2 - 1])) - ((v1[2 - 1]) * (v2[1 - 1]))]) + mag = 0.0 + for i in range(1, 3 + 1): + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=arg1, Magnitude=0.0) + return result + + +def IfcCurveDim(curve): + + if 'ifc4x3_rc2.ifcline' in typeof(curve): + return curve.Pnt.Dim + if 'ifc4x3_rc2.ifcconic' in typeof(curve): + return curve.Position.Dim + if 'ifc4x3_rc2.ifcpolyline' in typeof(curve): + return curve.Points[1 - 1].Dim + if 'ifc4x3_rc2.ifctrimmedcurve' in typeof(curve): + return IfcCurveDim(curve.BasisCurve) + if 'ifc4x3_rc2.ifccompositecurve' in typeof(curve): + return curve.Segments[1 - 1].Dim + if 'ifc4x3_rc2.ifcbsplinecurve' in typeof(curve): + return curve.ControlPointsList[1 - 1].Dim + if 'ifc4x3_rc2.ifcoffsetcurve2d' in typeof(curve): + return 2 + if 'ifc4x3_rc2.ifcoffsetcurve3d' in typeof(curve): + return 3 + if 'ifc4x3_rc2.ifcoffsetcurvebydistances' in typeof(curve): + return 3 + if 'ifc4x3_rc2.ifccurvesegment2d' in typeof(curve): + return 2 + if 'ifc4x3_rc2.ifcgradientcurve' in typeof(curve): + return 3 + if 'ifc4x3_rc2.ifcsegmentedreferencecurve' in typeof(curve): + return 3 + if 'ifc4x3_rc2.ifcseriesparametercurve' in typeof(curve): + return 3 + if 'ifc4x3_rc2.ifcpcurve' in typeof(curve): + return 3 + if 'ifc4x3_rc2.ifcindexedpolycurve' in typeof(curve): + return curve.Points.Dim + return None + + +def IfcCurveWeightsPositive(b): + result = True + for i in range(0, b.UpperIndexOnControlPoints + 1): + if (b.Weights[i - 1]) <= 0.0: + result = False + return result + return result + + +def IfcDeriveDimensionalExponents(unitelements): + result = IfcDimensionalExponents(0,0,0,0,0,0,0) + for i in range(loindex(unitelements), hiindex(unitelements) + 1): + result.LengthExponent = result.LengthExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LengthExponent)) + result.MassExponent = result.MassExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.MassExponent)) + result.TimeExponent = result.TimeExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.TimeExponent)) + result.ElectricCurrentExponent = result.ElectricCurrentExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ElectricCurrentExponent)) + result.ThermodynamicTemperatureExponent = result.ThermodynamicTemperatureExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ThermodynamicTemperatureExponent)) + result.AmountOfSubstanceExponent = result.AmountOfSubstanceExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.AmountOfSubstanceExponent)) + result.LuminousIntensityExponent = result.LuminousIntensityExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LuminousIntensityExponent)) + return result + + +def IfcDimensionsForSiUnit(n): + + if n == metre: + return IfcDimensionalExponents(1,0,0,0,0,0,0) + elif n == square_metre: + return IfcDimensionalExponents(2,0,0,0,0,0,0) + elif n == cubic_metre: + return IfcDimensionalExponents(3,0,0,0,0,0,0) + elif n == gram: + return IfcDimensionalExponents(0,1,0,0,0,0,0) + elif n == second: + return IfcDimensionalExponents(0,0,1,0,0,0,0) + elif n == ampere: + return IfcDimensionalExponents(0,0,0,1,0,0,0) + elif n == kelvin: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == mole: + return IfcDimensionalExponents(0,0,0,0,0,1,0) + elif n == candela: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == radian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == steradian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == hertz: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == newton: + return IfcDimensionalExponents(1,1,-2,0,0,0,0) + elif n == pascal: + return IfcDimensionalExponents(-1,1,-2,0,0,0,0) + elif n == joule: + return IfcDimensionalExponents(2,1,-2,0,0,0,0) + elif n == watt: + return IfcDimensionalExponents(2,1,-3,0,0,0,0) + elif n == coulomb: + return IfcDimensionalExponents(0,0,1,1,0,0,0) + elif n == volt: + return IfcDimensionalExponents(2,1,-3,-1,0,0,0) + elif n == farad: + return IfcDimensionalExponents(-2,-1,4,2,0,0,0) + elif n == ohm: + return IfcDimensionalExponents(2,1,-3,-2,0,0,0) + elif n == siemens: + return IfcDimensionalExponents(-2,-1,3,2,0,0,0) + elif n == weber: + return IfcDimensionalExponents(2,1,-2,-1,0,0,0) + elif n == tesla: + return IfcDimensionalExponents(0,1,-2,-1,0,0,0) + elif n == henry: + return IfcDimensionalExponents(2,1,-2,-2,0,0,0) + elif n == degree_celsius: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == lumen: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == lux: + return IfcDimensionalExponents(-2,0,0,0,0,0,1) + elif n == becquerel: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == gray: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + elif n == sievert: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + else: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + + +def IfcDotProduct(arg1, arg2): + + + + if (not exists(arg1)) or (not exists(arg2)): + scalar = None + else: + if arg1.Dim != arg2.Dim: + scalar = None + else: + vec1 = IfcNormalise(arg1) + vec2 = IfcNormalise(arg2) + ndim = arg1.Dim + scalar = 0.0 + for i in range(1, ndim + 1): + scalar = scalar + ((vec1.DirectionRatios[i - 1]) * (vec2.DirectionRatios[i - 1])) + return scalar + + +def IfcFirstProjAxis(zaxis, arg): + + + + + if not exists(zaxis): + return None + else: + z = IfcNormalise(zaxis) + if not exists(arg): + if z.DirectionRatios != [1.0,0.0,0.0]: + v = IfcDirection(DirectionRatios=[1.0,0.0,0.0]) + else: + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + if arg.Dim != 3: + return None + if IfcCrossProduct(arg,z).Magnitude == 0.0: + return None + else: + v = IfcNormalise(arg) + xvec = IfcScalarTimesVector(IfcDotProduct(v,z),z) + xaxis = IfcVectorDifference(v,xvec).Orientation + xaxis = IfcNormalise(xaxis) + return xaxis + + +def IfcGetBasisSurface(c): + + + surfs = [] + if 'ifc4x3_rc2.ifcpcurve' in typeof(c): + surfs = [c.BasisSurface] + else: + if 'ifc4x3_rc2.ifcsurfacecurve' in typeof(c): + n = sizeof(c.AssociatedGeometry) + for i in range(1, n + 1): + surfs = surfs + (IfcAssociatedSurface(c.AssociatedGeometry[i - 1])) + if 'ifc4x3_rc2.ifccompositecurveonsurface' in typeof(c): + n = sizeof(c.Segments) + surfs = IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve) + if n > 1: + for i in range(2, n + 1): + surfs = surfs * (IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve)) + return surfs + + +def IfcGradient(gradientcurve): + + return 1 + + +def IfcListToArray(lis, low, u): + + + n = sizeof(lis) + if n != (u - low + 1): + return None + else: + res = ([lis[1 - 1]] * n) + for i in range(2, n + 1): + temp = list(res) + temp[low - 1] = lis[i - 1] + res = temp + return res + + +def IfcLoopHeadToTail(aloop): + + p = True + n = sizeof(aloop.EdgeList) + for i in range(2, n + 1): + p = p and ((aloop.EdgeList[i - 1].EdgeEnd) == (aloop.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcMakeArrayOfArray(lis, low1, u1, low2, u2): + + if (u1 - low1 + 1) != sizeof(lis): + return None + if (u2 - low2 + 1) != (sizeof(lis[1 - 1])): + return None + res = ([IfcListToArray(lis[1 - 1],low2,u2)] * u1 - low1 + 1) + for i in range(2, hiindex(lis) + 1): + if (u2 - low2 + 1) != (sizeof(lis[i - 1])): + return None + temp = list(res) + temp[low1 - 1] = IfcListToArray(lis[i - 1],low2,u2) + res = temp + return res + + +def IfcMlsTotalThickness(layerset): + max = layerset.MaterialLayers[1 - 1].LayerThickness + if sizeof(layerset.MaterialLayers) > 1: + for i in range(2, hiindex(layerset.MaterialLayers) + 1): + max = max + (layerset.MaterialLayers[i - 1].LayerThickness) + return max + + +def IfcNormalise(arg): + + v = IfcDirection(DirectionRatios=[1.,0.]) + vec = IfcVector(Orientation=IfcDirection(DirectionRatios=[1.,0.]), Magnitude=1.) + + result = v + if not exists(arg): + return None + else: + if 'ifc4x3_rc2.ifcvector' in typeof(arg): + ndim = arg.Dim + v.DirectionRatios = arg.Orientation.DirectionRatios + vec.Magnitude = arg.Magnitude + vec.Orientation = v + if arg.Magnitude == 0.0: + return None + else: + vec.Magnitude = 1.0 + else: + ndim = arg.Dim + v.DirectionRatios = arg.DirectionRatios + mag = 0.0 + for i in range(1, ndim + 1): + mag = mag + ((v.DirectionRatios[i - 1]) * (v.DirectionRatios[i - 1])) + if mag > 0.0: + mag = sqrt(mag) + for i in range(1, ndim + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = (v.DirectionRatios[i - 1]) / mag + v.DirectionRatios = temp + if 'ifc4x3_rc2.ifcvector' in typeof(arg): + vec.Orientation = v + result = vec + else: + result = v + else: + return None + return result + + +def IfcOrthogonalComplement(vec): + + if (not exists(vec)) or (vec.Dim != 2): + return None + else: + result = IfcDirection(DirectionRatios=[-vec.DirectionRatios[2 - 1],vec.DirectionRatios[1 - 1]]) + return result + + +def IfcPathHeadToTail(apath): + n = 0 + p = unknown + n = sizeof(apath.EdgeList) + for i in range(2, n + 1): + p = p and ((apath.EdgeList[i - 1].EdgeEnd) == (apath.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcPointListDim(pointlist): + + if 'ifc4x3_rc2.ifccartesianpointlist2d' in typeof(pointlist): + return 2 + if 'ifc4x3_rc2.ifccartesianpointlist3d' in typeof(pointlist): + return 3 + return None + + +def IfcSameAxis2Placement(ap1, ap2, epsilon): + + return (IfcSameDirection(ap1.P[1 - 1],ap2.P[1 - 1],epsilon)) and (IfcSameDirection(ap1.P[2 - 1],ap2.P[2 - 1],epsilon)) and IfcSameCartesianPoint(ap1.Location,ap1.Location,epsilon) + + +def IfcSameCartesianPoint(cp1, cp2, epsilon): + cp1x = cp1.Coordinates[1 - 1] + cp1y = cp1.Coordinates[2 - 1] + cp1z = 0 + cp2x = cp2.Coordinates[1 - 1] + cp2y = cp2.Coordinates[2 - 1] + cp2z = 0 + if sizeof(cp1.Coordinates) > 2: + cp1z = cp1.Coordinates[3 - 1] + if sizeof(cp2.Coordinates) > 2: + cp2z = cp2.Coordinates[3 - 1] + return IfcSameValue(cp1x,cp2x,epsilon) and IfcSameValue(cp1y,cp2y,epsilon) and IfcSameValue(cp1z,cp2z,epsilon) + + +def IfcSameDirection(dir1, dir2, epsilon): + dir1x = dir1.DirectionRatios[1 - 1] + dir1y = dir1.DirectionRatios[2 - 1] + dir1z = 0 + dir2x = dir2.DirectionRatios[1 - 1] + dir2y = dir2.DirectionRatios[2 - 1] + dir2z = 0 + if sizeof(dir1.DirectionRatios) > 2: + dir1z = dir1.DirectionRatios[3 - 1] + if sizeof(dir2.DirectionRatios) > 2: + dir2z = dir2.DirectionRatios[3 - 1] + return IfcSameValue(dir1x,dir2x,epsilon) and IfcSameValue(dir1y,dir2y,epsilon) and IfcSameValue(dir1z,dir2z,epsilon) + + +def IfcSameValidPrecision(epsilon1, epsilon2): + + defaulteps = 0.000001 + derivationofeps = 1.001 + uppereps = 1.0 + valideps1 = nvl(epsilon1,defaulteps) + valideps2 = nvl(epsilon2,defaulteps) + return (0.0 < valideps1) and (valideps1 <= (derivationofeps * valideps2)) and (valideps2 <= (derivationofeps * valideps1)) and (valideps2 < uppereps) + + +def IfcSameValue(value1, value2, epsilon): + + defaulteps = 0.000001 + valideps = nvl(epsilon,defaulteps) + return ((value1 + valideps) > value2) and (value1 < (value2 + valideps)) + + +def IfcScalarTimesVector(scalar, vec): + + + + if (not exists(scalar)) or (not exists(vec)): + return None + else: + if 'ifc4x3_rc2.ifcvector' in typeof(vec): + v = vec.Orientation + mag = scalar * vec.Magnitude + else: + v = vec + mag = scalar + if mag < 0.0: + for i in range(1, sizeof(v.DirectionRatios) + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = -v.DirectionRatios[i - 1] + v.DirectionRatios = temp + mag = -mag + result = IfcVector(Orientation=IfcNormalise(v), Magnitude=mag) + return result + + +def IfcSecondProjAxis(zaxis, xaxis, arg): + + + + if not exists(arg): + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + v = arg + temp = IfcScalarTimesVector(IfcDotProduct(v,zaxis),zaxis) + yaxis = IfcVectorDifference(v,temp) + temp = IfcScalarTimesVector(IfcDotProduct(v,xaxis),xaxis) + yaxis = IfcVectorDifference(yaxis,temp) + yaxis = IfcNormalise(yaxis) + return yaxis.Orientation + + +def IfcShapeRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'point': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifcpoint' in typeof(temp)]) + elif reptype.lower() == 'pointcloud': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifccartesianpointlist3d' in typeof(temp)]) + elif reptype.lower() == 'curve': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifccurve' in typeof(temp)]) + elif reptype.lower() == 'curve2d': + count = sizeof([temp for temp in items if ('ifc4x3_rc2.ifccurve' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'curve3d': + count = sizeof([temp for temp in items if ('ifc4x3_rc2.ifccurve' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'surface': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifcsurface' in typeof(temp)]) + elif reptype.lower() == 'surface2d': + count = sizeof([temp for temp in items if ('ifc4x3_rc2.ifcsurface' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'surface3d': + count = sizeof([temp for temp in items if ('ifc4x3_rc2.ifcsurface' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'fillarea': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifcannotationfillarea' in typeof(temp)]) + elif reptype.lower() == 'text': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifctextliteral' in typeof(temp)]) + elif reptype.lower() == 'advancedsurface': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifcbsplinesurface' in typeof(temp)]) + elif reptype.lower() == 'annotation2d': + count = sizeof([temp for temp in items if (sizeof(typeof(temp) * ['ifc4x3_rc2.ifcpoint','ifc4x3_rc2.ifccurve','ifc4x3_rc2.ifcgeometriccurveset','ifc4x3_rc2.ifcannotationfillarea','ifc4x3_rc2.ifctextliteral'])) == 1]) + elif reptype.lower() == 'geometricset': + count = sizeof([temp for temp in items if ('ifc4x3_rc2.ifcgeometricset' in typeof(temp)) or ('ifc4x3_rc2.ifcpoint' in typeof(temp)) or ('ifc4x3_rc2.ifccurve' in typeof(temp)) or ('ifc4x3_rc2.ifcsurface' in typeof(temp))]) + elif reptype.lower() == 'geometriccurveset': + count = sizeof([temp for temp in items if ('ifc4x3_rc2.ifcgeometriccurveset' in typeof(temp)) or ('ifc4x3_rc2.ifcgeometricset' in typeof(temp)) or ('ifc4x3_rc2.ifcpoint' in typeof(temp)) or ('ifc4x3_rc2.ifccurve' in typeof(temp))]) + for i in range(1, hiindex(items) + 1): + if 'ifc4x3_rc2.ifcgeometricset' in (typeof(items[i - 1])): + if (sizeof([temp for temp in items[i - 1].Elements if 'ifc4x3_rc2.ifcsurface' in typeof(temp)])) > 0: + count = count - 1 + elif reptype.lower() == 'tessellation': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifctessellateditem' in typeof(temp)]) + elif reptype.lower() == 'surfaceorsolidmodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc2.ifctessellateditem','ifc4x3_rc2.ifcshellbasedsurfacemodel','ifc4x3_rc2.ifcfacebasedsurfacemodel','ifc4x3_rc2.ifcsolidmodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'surfacemodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc2.ifctessellateditem','ifc4x3_rc2.ifcshellbasedsurfacemodel','ifc4x3_rc2.ifcfacebasedsurfacemodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'solidmodel': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifcsolidmodel' in typeof(temp)]) + elif reptype.lower() == 'sweptsolid': + count = sizeof([temp for temp in items if ((sizeof(['ifc4x3_rc2.ifcextrudedareasolid','ifc4x3_rc2.ifcrevolvedareasolid'] * typeof(temp))) >= 1) and ((sizeof(['ifc4x3_rc2.ifcextrudedareasolidtapered','ifc4x3_rc2.ifcrevolvedareasolidtapered'] * typeof(temp))) == 0)]) + elif reptype.lower() == 'advancedsweptsolid': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc2.ifcsweptareasolid','ifc4x3_rc2.ifcsweptdisksolid'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'csg': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc2.ifcbooleanresult','ifc4x3_rc2.ifccsgprimitive3d','ifc4x3_rc2.ifccsgsolid'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'clipping': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc2.ifccsgsolid','ifc4x3_rc2.ifcbooleanclippingresult'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'brep': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifcfacetedbrep' in typeof(temp)]) + elif reptype.lower() == 'advancedbrep': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifcmanifoldsolidbrep' in typeof(temp)]) + elif reptype.lower() == 'boundingbox': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifcboundingbox' in typeof(temp)]) + if sizeof(items) > 1: + count = 0 + elif reptype.lower() == 'sectionedspine': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifcsectionedspine' in typeof(temp)]) + elif reptype.lower() == 'lightsource': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifclightsource' in typeof(temp)]) + elif reptype.lower() == 'mappedrepresentation': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifcmappeditem' in typeof(temp)]) + else: + return None + return count == sizeof(items) + + +def IfcSurfaceWeightsPositive(b): + result = True + weights = b.Weights + for i in range(0, b.UUpper + 1): + for j in range(0, b.VUpper + 1): + if (weights[i - 1][j - 1]) <= 0.0: + result = False + return result + return result + + +def IfcTaperedSweptAreaProfiles(startarea, endarea): + result = False + if 'ifc4x3_rc2.ifcparameterizedprofiledef' in typeof(startarea): + if 'ifc4x3_rc2.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = typeof(startarea) == typeof(endarea) + else: + if 'ifc4x3_rc2.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = False + return result + + +def IfcTopologyRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'vertex': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifcvertex' in typeof(temp)]) + elif reptype.lower() == 'edge': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifcedge' in typeof(temp)]) + elif reptype.lower() == 'path': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifcpath' in typeof(temp)]) + elif reptype.lower() == 'face': + count = sizeof([temp for temp in items if 'ifc4x3_rc2.ifcface' in typeof(temp)]) + elif reptype.lower() == 'shell': + count = sizeof([temp for temp in items if ('ifc4x3_rc2.ifcopenshell' in typeof(temp)) or ('ifc4x3_rc2.ifcclosedshell' in typeof(temp))]) + elif reptype.lower() == 'undefined': + return True + else: + return None + return count == sizeof(items) + + +def IfcUniqueDefinitionNames(relations): + + + properties = express_set([]) + + if sizeof(relations) == 0: + return True + for i in range(1, hiindex(relations) + 1): + definition = relations[i - 1].RelatingPropertyDefinition + if 'ifc4x3_rc2.ifcpropertysetdefinition' in typeof(definition): + properties = properties + definition + else: + if 'ifc4x3_rc2.ifcpropertysetdefinitionset' in typeof(definition): + definitionset = definition + for j in range(1, hiindex(definitionset) + 1): + properties = properties + (definitionset[j - 1]) + result = IfcUniquePropertySetNames(properties) + return result + + +def IfcUniquePropertyName(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniquePropertySetNames(properties): + names = express_set([]) + unnamed = 0 + for i in range(1, hiindex(properties) + 1): + if 'ifc4x3_rc2.ifcpropertyset' in (typeof(properties[i - 1])): + names = names + (properties[i - 1].Name) + else: + unnamed = unnamed + 1 + return (sizeof(names) + unnamed) == sizeof(properties) + + +def IfcUniquePropertyTemplateNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniqueQuantityNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcVectorDifference(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x3_rc2.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x3_rc2.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) - (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + +def IfcVectorSum(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x3_rc2.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x3_rc2.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) + (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + diff --git a/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_RC3.py b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_RC3.py new file mode 100644 index 0000000000..5f421c24ed --- /dev/null +++ b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_RC3.py @@ -0,0 +1,25052 @@ +import ifcopenshell + +def exists(v): + if callable(v): + try: return v() is not None + except IndexError as e: return False + else: return v is not None + + + +def nvl(v, default): return v if v is not None else default + + +sizeof = len +hiindex = len +blength = len +loindex = lambda x: 1 +from math import * +unknown = 'UNKNOWN' + +def usedin(inst, ref_name): + if inst is None: + return [] + _, __, attr = ref_name.split('.') + def filter(): + for ref, attr_idx in inst.wrapped_data.file.get_inverse(inst, allow_duplicate=True, with_attribute_indices=True): + if ref.wrapped_data.get_attribute_names()[attr_idx].lower() == attr: + yield ref + return list(filter()) + + +class express_set(set): + def __rmul__(self, other): + return express_set(set(other) & self) + def __add__(self, other): + def make_list(v): + # Comply with 12.6.3 Union operator + if isinstance(v, (list, tuple, set, express_set)): + return list(v) + else: + return [v] + return express_set(list(self) + make_list(other)) + __radd__ = __add__ + def __repr__(self): + return repr(set(self)) + + +def typeof(inst): + if not inst: + # If V evaluates to indeterminate (?), an empty set is returned. + return express_set([]) + schema_name = inst.is_a(True).split('.')[0].lower() + def inner(): + decl = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(inst.is_a()) + while decl: + yield '.'.join((schema_name, decl.name().lower())) + decl = decl.supertype() + return express_set(inner()) + +class enum_namespace: + def __getattr__(self, k): + return k.upper() + + +IfcActionRequestTypeEnum = enum_namespace() + + +email = IfcActionRequestTypeEnum.EMAIL + + +fax = IfcActionRequestTypeEnum.FAX + + +phone = IfcActionRequestTypeEnum.PHONE + + +post = IfcActionRequestTypeEnum.POST + + +verbal = IfcActionRequestTypeEnum.VERBAL + + +userdefined = IfcActionRequestTypeEnum.USERDEFINED + + +notdefined = IfcActionRequestTypeEnum.NOTDEFINED + + +IfcActionSourceTypeEnum = enum_namespace() + + +dead_load_g = IfcActionSourceTypeEnum.DEAD_LOAD_G + + +completion_g1 = IfcActionSourceTypeEnum.COMPLETION_G1 + + +live_load_q = IfcActionSourceTypeEnum.LIVE_LOAD_Q + + +snow_s = IfcActionSourceTypeEnum.SNOW_S + + +wind_w = IfcActionSourceTypeEnum.WIND_W + + +prestressing_p = IfcActionSourceTypeEnum.PRESTRESSING_P + + +settlement_u = IfcActionSourceTypeEnum.SETTLEMENT_U + + +temperature_t = IfcActionSourceTypeEnum.TEMPERATURE_T + + +earthquake_e = IfcActionSourceTypeEnum.EARTHQUAKE_E + + +fire = IfcActionSourceTypeEnum.FIRE + + +impulse = IfcActionSourceTypeEnum.IMPULSE + + +impact = IfcActionSourceTypeEnum.IMPACT + + +transport = IfcActionSourceTypeEnum.TRANSPORT + + +erection = IfcActionSourceTypeEnum.ERECTION + + +propping = IfcActionSourceTypeEnum.PROPPING + + +system_imperfection = IfcActionSourceTypeEnum.SYSTEM_IMPERFECTION + + +shrinkage = IfcActionSourceTypeEnum.SHRINKAGE + + +creep = IfcActionSourceTypeEnum.CREEP + + +lack_of_fit = IfcActionSourceTypeEnum.LACK_OF_FIT + + +buoyancy = IfcActionSourceTypeEnum.BUOYANCY + + +ice = IfcActionSourceTypeEnum.ICE + + +current = IfcActionSourceTypeEnum.CURRENT + + +wave = IfcActionSourceTypeEnum.WAVE + + +rain = IfcActionSourceTypeEnum.RAIN + + +brakes = IfcActionSourceTypeEnum.BRAKES + + +userdefined = IfcActionSourceTypeEnum.USERDEFINED + + +notdefined = IfcActionSourceTypeEnum.NOTDEFINED + + +IfcActionTypeEnum = enum_namespace() + + +permanent_g = IfcActionTypeEnum.PERMANENT_G + + +variable_q = IfcActionTypeEnum.VARIABLE_Q + + +extraordinary_a = IfcActionTypeEnum.EXTRAORDINARY_A + + +userdefined = IfcActionTypeEnum.USERDEFINED + + +notdefined = IfcActionTypeEnum.NOTDEFINED + + +IfcActuatorTypeEnum = enum_namespace() + + +electricactuator = IfcActuatorTypeEnum.ELECTRICACTUATOR + + +handoperatedactuator = IfcActuatorTypeEnum.HANDOPERATEDACTUATOR + + +hydraulicactuator = IfcActuatorTypeEnum.HYDRAULICACTUATOR + + +pneumaticactuator = IfcActuatorTypeEnum.PNEUMATICACTUATOR + + +thermostaticactuator = IfcActuatorTypeEnum.THERMOSTATICACTUATOR + + +userdefined = IfcActuatorTypeEnum.USERDEFINED + + +notdefined = IfcActuatorTypeEnum.NOTDEFINED + + +IfcAddressTypeEnum = enum_namespace() + + +office = IfcAddressTypeEnum.OFFICE + + +site = IfcAddressTypeEnum.SITE + + +home = IfcAddressTypeEnum.HOME + + +distributionpoint = IfcAddressTypeEnum.DISTRIBUTIONPOINT + + +userdefined = IfcAddressTypeEnum.USERDEFINED + + +IfcAirTerminalBoxTypeEnum = enum_namespace() + + +constantflow = IfcAirTerminalBoxTypeEnum.CONSTANTFLOW + + +variableflowpressuredependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREDEPENDANT + + +variableflowpressureindependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREINDEPENDANT + + +userdefined = IfcAirTerminalBoxTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalBoxTypeEnum.NOTDEFINED + + +IfcAirTerminalTypeEnum = enum_namespace() + + +diffuser = IfcAirTerminalTypeEnum.DIFFUSER + + +grille = IfcAirTerminalTypeEnum.GRILLE + + +louvre = IfcAirTerminalTypeEnum.LOUVRE + + +register = IfcAirTerminalTypeEnum.REGISTER + + +userdefined = IfcAirTerminalTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalTypeEnum.NOTDEFINED + + +IfcAirToAirHeatRecoveryTypeEnum = enum_namespace() + + +fixedplatecounterflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECOUNTERFLOWEXCHANGER + + +fixedplatecrossflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECROSSFLOWEXCHANGER + + +fixedplateparallelflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATEPARALLELFLOWEXCHANGER + + +rotarywheel = IfcAirToAirHeatRecoveryTypeEnum.ROTARYWHEEL + + +runaroundcoilloop = IfcAirToAirHeatRecoveryTypeEnum.RUNAROUNDCOILLOOP + + +heatpipe = IfcAirToAirHeatRecoveryTypeEnum.HEATPIPE + + +twintowerenthalpyrecoveryloops = IfcAirToAirHeatRecoveryTypeEnum.TWINTOWERENTHALPYRECOVERYLOOPS + + +thermosiphonsealedtubeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONSEALEDTUBEHEATEXCHANGERS + + +thermosiphoncoiltypeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONCOILTYPEHEATEXCHANGERS + + +userdefined = IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED + + +notdefined = IfcAirToAirHeatRecoveryTypeEnum.NOTDEFINED + + +IfcAlarmTypeEnum = enum_namespace() + + +bell = IfcAlarmTypeEnum.BELL + + +breakglassbutton = IfcAlarmTypeEnum.BREAKGLASSBUTTON + + +light = IfcAlarmTypeEnum.LIGHT + + +manualpullbox = IfcAlarmTypeEnum.MANUALPULLBOX + + +siren = IfcAlarmTypeEnum.SIREN + + +whistle = IfcAlarmTypeEnum.WHISTLE + + +railwaycrocodile = IfcAlarmTypeEnum.RAILWAYCROCODILE + + +railwaydetonator = IfcAlarmTypeEnum.RAILWAYDETONATOR + + +userdefined = IfcAlarmTypeEnum.USERDEFINED + + +notdefined = IfcAlarmTypeEnum.NOTDEFINED + + +IfcAlignmentCantSegmentTypeEnum = enum_namespace() + + +constantcant = IfcAlignmentCantSegmentTypeEnum.CONSTANTCANT + + +lineartransition = IfcAlignmentCantSegmentTypeEnum.LINEARTRANSITION + + +helmertcurve = IfcAlignmentCantSegmentTypeEnum.HELMERTCURVE + + +blosscurve = IfcAlignmentCantSegmentTypeEnum.BLOSSCURVE + + +cosinecurve = IfcAlignmentCantSegmentTypeEnum.COSINECURVE + + +sinecurve = IfcAlignmentCantSegmentTypeEnum.SINECURVE + + +viennesebend = IfcAlignmentCantSegmentTypeEnum.VIENNESEBEND + + +IfcAlignmentHorizontalSegmentTypeEnum = enum_namespace() + + +line = IfcAlignmentHorizontalSegmentTypeEnum.LINE + + +circulararc = IfcAlignmentHorizontalSegmentTypeEnum.CIRCULARARC + + +clothoid = IfcAlignmentHorizontalSegmentTypeEnum.CLOTHOID + + +cubic = IfcAlignmentHorizontalSegmentTypeEnum.CUBIC + + +helmertcurve = IfcAlignmentHorizontalSegmentTypeEnum.HELMERTCURVE + + +blosscurve = IfcAlignmentHorizontalSegmentTypeEnum.BLOSSCURVE + + +cubicspiral = IfcAlignmentHorizontalSegmentTypeEnum.CUBICSPIRAL + + +cosinecurve = IfcAlignmentHorizontalSegmentTypeEnum.COSINECURVE + + +sinecurve = IfcAlignmentHorizontalSegmentTypeEnum.SINECURVE + + +viennesebend = IfcAlignmentHorizontalSegmentTypeEnum.VIENNESEBEND + + +IfcAlignmentTypeEnum = enum_namespace() + + +userdefined = IfcAlignmentTypeEnum.USERDEFINED + + +notdefined = IfcAlignmentTypeEnum.NOTDEFINED + + +IfcAlignmentVerticalSegmentTypeEnum = enum_namespace() + + +constantgradient = IfcAlignmentVerticalSegmentTypeEnum.CONSTANTGRADIENT + + +circulararc = IfcAlignmentVerticalSegmentTypeEnum.CIRCULARARC + + +parabolicarc = IfcAlignmentVerticalSegmentTypeEnum.PARABOLICARC + + +clothoid = IfcAlignmentVerticalSegmentTypeEnum.CLOTHOID + + +IfcAnalysisModelTypeEnum = enum_namespace() + + +in_plane_loading_2d = IfcAnalysisModelTypeEnum.IN_PLANE_LOADING_2D + + +out_plane_loading_2d = IfcAnalysisModelTypeEnum.OUT_PLANE_LOADING_2D + + +loading_3d = IfcAnalysisModelTypeEnum.LOADING_3D + + +userdefined = IfcAnalysisModelTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisModelTypeEnum.NOTDEFINED + + +IfcAnalysisTheoryTypeEnum = enum_namespace() + + +first_order_theory = IfcAnalysisTheoryTypeEnum.FIRST_ORDER_THEORY + + +second_order_theory = IfcAnalysisTheoryTypeEnum.SECOND_ORDER_THEORY + + +third_order_theory = IfcAnalysisTheoryTypeEnum.THIRD_ORDER_THEORY + + +full_nonlinear_theory = IfcAnalysisTheoryTypeEnum.FULL_NONLINEAR_THEORY + + +userdefined = IfcAnalysisTheoryTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisTheoryTypeEnum.NOTDEFINED + + +IfcAnnotationTypeEnum = enum_namespace() + + +assumedpoint = IfcAnnotationTypeEnum.ASSUMEDPOINT + + +asbuiltarea = IfcAnnotationTypeEnum.ASBUILTAREA + + +asbuiltline = IfcAnnotationTypeEnum.ASBUILTLINE + + +non_physical_signal = IfcAnnotationTypeEnum.NON_PHYSICAL_SIGNAL + + +assumedline = IfcAnnotationTypeEnum.ASSUMEDLINE + + +widthevent = IfcAnnotationTypeEnum.WIDTHEVENT + + +assumedarea = IfcAnnotationTypeEnum.ASSUMEDAREA + + +superelevationevent = IfcAnnotationTypeEnum.SUPERELEVATIONEVENT + + +asbuiltpoint = IfcAnnotationTypeEnum.ASBUILTPOINT + + +userdefined = IfcAnnotationTypeEnum.USERDEFINED + + +notdefined = IfcAnnotationTypeEnum.NOTDEFINED + + +IfcArithmeticOperatorEnum = enum_namespace() + + +add = IfcArithmeticOperatorEnum.ADD + + +divide = IfcArithmeticOperatorEnum.DIVIDE + + +multiply = IfcArithmeticOperatorEnum.MULTIPLY + + +subtract = IfcArithmeticOperatorEnum.SUBTRACT + + +IfcAssemblyPlaceEnum = enum_namespace() + + +site = IfcAssemblyPlaceEnum.SITE + + +factory = IfcAssemblyPlaceEnum.FACTORY + + +notdefined = IfcAssemblyPlaceEnum.NOTDEFINED + + +IfcAudioVisualApplianceTypeEnum = enum_namespace() + + +amplifier = IfcAudioVisualApplianceTypeEnum.AMPLIFIER + + +camera = IfcAudioVisualApplianceTypeEnum.CAMERA + + +display = IfcAudioVisualApplianceTypeEnum.DISPLAY + + +microphone = IfcAudioVisualApplianceTypeEnum.MICROPHONE + + +player = IfcAudioVisualApplianceTypeEnum.PLAYER + + +projector = IfcAudioVisualApplianceTypeEnum.PROJECTOR + + +receiver = IfcAudioVisualApplianceTypeEnum.RECEIVER + + +speaker = IfcAudioVisualApplianceTypeEnum.SPEAKER + + +switcher = IfcAudioVisualApplianceTypeEnum.SWITCHER + + +telephone = IfcAudioVisualApplianceTypeEnum.TELEPHONE + + +tuner = IfcAudioVisualApplianceTypeEnum.TUNER + + +railway_communication_terminal = IfcAudioVisualApplianceTypeEnum.RAILWAY_COMMUNICATION_TERMINAL + + +userdefined = IfcAudioVisualApplianceTypeEnum.USERDEFINED + + +notdefined = IfcAudioVisualApplianceTypeEnum.NOTDEFINED + + +IfcBSplineCurveForm = enum_namespace() + + +polyline_form = IfcBSplineCurveForm.POLYLINE_FORM + + +circular_arc = IfcBSplineCurveForm.CIRCULAR_ARC + + +elliptic_arc = IfcBSplineCurveForm.ELLIPTIC_ARC + + +parabolic_arc = IfcBSplineCurveForm.PARABOLIC_ARC + + +hyperbolic_arc = IfcBSplineCurveForm.HYPERBOLIC_ARC + + +unspecified = IfcBSplineCurveForm.UNSPECIFIED + + +IfcBSplineSurfaceForm = enum_namespace() + + +plane_surf = IfcBSplineSurfaceForm.PLANE_SURF + + +cylindrical_surf = IfcBSplineSurfaceForm.CYLINDRICAL_SURF + + +conical_surf = IfcBSplineSurfaceForm.CONICAL_SURF + + +spherical_surf = IfcBSplineSurfaceForm.SPHERICAL_SURF + + +toroidal_surf = IfcBSplineSurfaceForm.TOROIDAL_SURF + + +surf_of_revolution = IfcBSplineSurfaceForm.SURF_OF_REVOLUTION + + +ruled_surf = IfcBSplineSurfaceForm.RULED_SURF + + +generalised_cone = IfcBSplineSurfaceForm.GENERALISED_CONE + + +quadric_surf = IfcBSplineSurfaceForm.QUADRIC_SURF + + +surf_of_linear_extrusion = IfcBSplineSurfaceForm.SURF_OF_LINEAR_EXTRUSION + + +unspecified = IfcBSplineSurfaceForm.UNSPECIFIED + + +IfcBeamTypeEnum = enum_namespace() + + +beam = IfcBeamTypeEnum.BEAM + + +joist = IfcBeamTypeEnum.JOIST + + +hollowcore = IfcBeamTypeEnum.HOLLOWCORE + + +lintel = IfcBeamTypeEnum.LINTEL + + +spandrel = IfcBeamTypeEnum.SPANDREL + + +t_beam = IfcBeamTypeEnum.T_BEAM + + +girder_segment = IfcBeamTypeEnum.GIRDER_SEGMENT + + +diaphragm = IfcBeamTypeEnum.DIAPHRAGM + + +piercap = IfcBeamTypeEnum.PIERCAP + + +hatstone = IfcBeamTypeEnum.HATSTONE + + +cornice = IfcBeamTypeEnum.CORNICE + + +edgebeam = IfcBeamTypeEnum.EDGEBEAM + + +userdefined = IfcBeamTypeEnum.USERDEFINED + + +notdefined = IfcBeamTypeEnum.NOTDEFINED + + +IfcBearingTypeDisplacementEnum = enum_namespace() + + +fixed_movement = IfcBearingTypeDisplacementEnum.FIXED_MOVEMENT + + +guided_longitudinal = IfcBearingTypeDisplacementEnum.GUIDED_LONGITUDINAL + + +guided_transversal = IfcBearingTypeDisplacementEnum.GUIDED_TRANSVERSAL + + +free_movement = IfcBearingTypeDisplacementEnum.FREE_MOVEMENT + + +notdefined = IfcBearingTypeDisplacementEnum.NOTDEFINED + + +IfcBearingTypeEnum = enum_namespace() + + +cylindrical = IfcBearingTypeEnum.CYLINDRICAL + + +spherical = IfcBearingTypeEnum.SPHERICAL + + +elastomeric = IfcBearingTypeEnum.ELASTOMERIC + + +pot = IfcBearingTypeEnum.POT + + +guide = IfcBearingTypeEnum.GUIDE + + +rocker = IfcBearingTypeEnum.ROCKER + + +roller = IfcBearingTypeEnum.ROLLER + + +disk = IfcBearingTypeEnum.DISK + + +userdefined = IfcBearingTypeEnum.USERDEFINED + + +notdefined = IfcBearingTypeEnum.NOTDEFINED + + +IfcBenchmarkEnum = enum_namespace() + + +greaterthan = IfcBenchmarkEnum.GREATERTHAN + + +greaterthanorequalto = IfcBenchmarkEnum.GREATERTHANOREQUALTO + + +lessthan = IfcBenchmarkEnum.LESSTHAN + + +lessthanorequalto = IfcBenchmarkEnum.LESSTHANOREQUALTO + + +equalto = IfcBenchmarkEnum.EQUALTO + + +notequalto = IfcBenchmarkEnum.NOTEQUALTO + + +includes = IfcBenchmarkEnum.INCLUDES + + +notincludes = IfcBenchmarkEnum.NOTINCLUDES + + +includedin = IfcBenchmarkEnum.INCLUDEDIN + + +notincludedin = IfcBenchmarkEnum.NOTINCLUDEDIN + + +IfcBoilerTypeEnum = enum_namespace() + + +water = IfcBoilerTypeEnum.WATER + + +steam = IfcBoilerTypeEnum.STEAM + + +userdefined = IfcBoilerTypeEnum.USERDEFINED + + +notdefined = IfcBoilerTypeEnum.NOTDEFINED + + +IfcBooleanOperator = enum_namespace() + + +union = IfcBooleanOperator.UNION + + +intersection = IfcBooleanOperator.INTERSECTION + + +difference = IfcBooleanOperator.DIFFERENCE + + +IfcBridgePartTypeEnum = enum_namespace() + + +abutment = IfcBridgePartTypeEnum.ABUTMENT + + +deck = IfcBridgePartTypeEnum.DECK + + +deck_segment = IfcBridgePartTypeEnum.DECK_SEGMENT + + +foundation = IfcBridgePartTypeEnum.FOUNDATION + + +pier = IfcBridgePartTypeEnum.PIER + + +pier_segment = IfcBridgePartTypeEnum.PIER_SEGMENT + + +pylon = IfcBridgePartTypeEnum.PYLON + + +substructure = IfcBridgePartTypeEnum.SUBSTRUCTURE + + +superstructure = IfcBridgePartTypeEnum.SUPERSTRUCTURE + + +surfacestructure = IfcBridgePartTypeEnum.SURFACESTRUCTURE + + +userdefined = IfcBridgePartTypeEnum.USERDEFINED + + +notdefined = IfcBridgePartTypeEnum.NOTDEFINED + + +IfcBridgeTypeEnum = enum_namespace() + + +arched = IfcBridgeTypeEnum.ARCHED + + +cable_stayed = IfcBridgeTypeEnum.CABLE_STAYED + + +cantilever = IfcBridgeTypeEnum.CANTILEVER + + +culvert = IfcBridgeTypeEnum.CULVERT + + +framework = IfcBridgeTypeEnum.FRAMEWORK + + +girder = IfcBridgeTypeEnum.GIRDER + + +suspension = IfcBridgeTypeEnum.SUSPENSION + + +truss = IfcBridgeTypeEnum.TRUSS + + +userdefined = IfcBridgeTypeEnum.USERDEFINED + + +notdefined = IfcBridgeTypeEnum.NOTDEFINED + + +IfcBuildingElementPartTypeEnum = enum_namespace() + + +insulation = IfcBuildingElementPartTypeEnum.INSULATION + + +precastpanel = IfcBuildingElementPartTypeEnum.PRECASTPANEL + + +apron = IfcBuildingElementPartTypeEnum.APRON + + +armourunit = IfcBuildingElementPartTypeEnum.ARMOURUNIT + + +safetycage = IfcBuildingElementPartTypeEnum.SAFETYCAGE + + +userdefined = IfcBuildingElementPartTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementPartTypeEnum.NOTDEFINED + + +IfcBuildingElementProxyTypeEnum = enum_namespace() + + +complex = IfcBuildingElementProxyTypeEnum.COMPLEX + + +element = IfcBuildingElementProxyTypeEnum.ELEMENT + + +partial = IfcBuildingElementProxyTypeEnum.PARTIAL + + +provisionforvoid = IfcBuildingElementProxyTypeEnum.PROVISIONFORVOID + + +provisionforspace = IfcBuildingElementProxyTypeEnum.PROVISIONFORSPACE + + +userdefined = IfcBuildingElementProxyTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementProxyTypeEnum.NOTDEFINED + + +IfcBuildingSystemTypeEnum = enum_namespace() + + +fenestration = IfcBuildingSystemTypeEnum.FENESTRATION + + +foundation = IfcBuildingSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuildingSystemTypeEnum.LOADBEARING + + +outershell = IfcBuildingSystemTypeEnum.OUTERSHELL + + +shading = IfcBuildingSystemTypeEnum.SHADING + + +transport = IfcBuildingSystemTypeEnum.TRANSPORT + + +reinforcing = IfcBuildingSystemTypeEnum.REINFORCING + + +prestressing = IfcBuildingSystemTypeEnum.PRESTRESSING + + +erosionprevention = IfcBuildingSystemTypeEnum.EROSIONPREVENTION + + +userdefined = IfcBuildingSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuildingSystemTypeEnum.NOTDEFINED + + +IfcBuiltSystemTypeEnum = enum_namespace() + + +reinforcing = IfcBuiltSystemTypeEnum.REINFORCING + + +mooring = IfcBuiltSystemTypeEnum.MOORING + + +outershell = IfcBuiltSystemTypeEnum.OUTERSHELL + + +trackcircuit = IfcBuiltSystemTypeEnum.TRACKCIRCUIT + + +erosionprevention = IfcBuiltSystemTypeEnum.EROSIONPREVENTION + + +foundation = IfcBuiltSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuiltSystemTypeEnum.LOADBEARING + + +shading = IfcBuiltSystemTypeEnum.SHADING + + +fenestration = IfcBuiltSystemTypeEnum.FENESTRATION + + +mooringsystem = IfcBuiltSystemTypeEnum.MOORINGSYSTEM + + +transport = IfcBuiltSystemTypeEnum.TRANSPORT + + +prestressing = IfcBuiltSystemTypeEnum.PRESTRESSING + + +userdefined = IfcBuiltSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuiltSystemTypeEnum.NOTDEFINED + + +IfcBurnerTypeEnum = enum_namespace() + + +userdefined = IfcBurnerTypeEnum.USERDEFINED + + +notdefined = IfcBurnerTypeEnum.NOTDEFINED + + +IfcCableCarrierFittingTypeEnum = enum_namespace() + + +bend = IfcCableCarrierFittingTypeEnum.BEND + + +cross = IfcCableCarrierFittingTypeEnum.CROSS + + +reducer = IfcCableCarrierFittingTypeEnum.REDUCER + + +tee = IfcCableCarrierFittingTypeEnum.TEE + + +userdefined = IfcCableCarrierFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierFittingTypeEnum.NOTDEFINED + + +IfcCableCarrierSegmentTypeEnum = enum_namespace() + + +cableladdersegment = IfcCableCarrierSegmentTypeEnum.CABLELADDERSEGMENT + + +cabletraysegment = IfcCableCarrierSegmentTypeEnum.CABLETRAYSEGMENT + + +cabletrunkingsegment = IfcCableCarrierSegmentTypeEnum.CABLETRUNKINGSEGMENT + + +conduitsegment = IfcCableCarrierSegmentTypeEnum.CONDUITSEGMENT + + +cablebracket = IfcCableCarrierSegmentTypeEnum.CABLEBRACKET + + +catenarywire = IfcCableCarrierSegmentTypeEnum.CATENARYWIRE + + +dropper = IfcCableCarrierSegmentTypeEnum.DROPPER + + +userdefined = IfcCableCarrierSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierSegmentTypeEnum.NOTDEFINED + + +IfcCableFittingTypeEnum = enum_namespace() + + +connector = IfcCableFittingTypeEnum.CONNECTOR + + +entry = IfcCableFittingTypeEnum.ENTRY + + +exit = IfcCableFittingTypeEnum.EXIT + + +junction = IfcCableFittingTypeEnum.JUNCTION + + +transition = IfcCableFittingTypeEnum.TRANSITION + + +fanout = IfcCableFittingTypeEnum.FANOUT + + +userdefined = IfcCableFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableFittingTypeEnum.NOTDEFINED + + +IfcCableSegmentTypeEnum = enum_namespace() + + +busbarsegment = IfcCableSegmentTypeEnum.BUSBARSEGMENT + + +cablesegment = IfcCableSegmentTypeEnum.CABLESEGMENT + + +conductorsegment = IfcCableSegmentTypeEnum.CONDUCTORSEGMENT + + +coresegment = IfcCableSegmentTypeEnum.CORESEGMENT + + +contactwiresegment = IfcCableSegmentTypeEnum.CONTACTWIRESEGMENT + + +fibersegment = IfcCableSegmentTypeEnum.FIBERSEGMENT + + +fibertube = IfcCableSegmentTypeEnum.FIBERTUBE + + +opticalcablesegment = IfcCableSegmentTypeEnum.OPTICALCABLESEGMENT + + +stitchwire = IfcCableSegmentTypeEnum.STITCHWIRE + + +wirepairsegment = IfcCableSegmentTypeEnum.WIREPAIRSEGMENT + + +userdefined = IfcCableSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableSegmentTypeEnum.NOTDEFINED + + +IfcCaissonFoundationTypeEnum = enum_namespace() + + +well = IfcCaissonFoundationTypeEnum.WELL + + +caisson = IfcCaissonFoundationTypeEnum.CAISSON + + +userdefined = IfcCaissonFoundationTypeEnum.USERDEFINED + + +notdefined = IfcCaissonFoundationTypeEnum.NOTDEFINED + + +IfcChangeActionEnum = enum_namespace() + + +nochange = IfcChangeActionEnum.NOCHANGE + + +modified = IfcChangeActionEnum.MODIFIED + + +added = IfcChangeActionEnum.ADDED + + +deleted = IfcChangeActionEnum.DELETED + + +notdefined = IfcChangeActionEnum.NOTDEFINED + + +IfcChillerTypeEnum = enum_namespace() + + +aircooled = IfcChillerTypeEnum.AIRCOOLED + + +watercooled = IfcChillerTypeEnum.WATERCOOLED + + +heatrecovery = IfcChillerTypeEnum.HEATRECOVERY + + +userdefined = IfcChillerTypeEnum.USERDEFINED + + +notdefined = IfcChillerTypeEnum.NOTDEFINED + + +IfcChimneyTypeEnum = enum_namespace() + + +userdefined = IfcChimneyTypeEnum.USERDEFINED + + +notdefined = IfcChimneyTypeEnum.NOTDEFINED + + +IfcCoilTypeEnum = enum_namespace() + + +dxcoolingcoil = IfcCoilTypeEnum.DXCOOLINGCOIL + + +electricheatingcoil = IfcCoilTypeEnum.ELECTRICHEATINGCOIL + + +gasheatingcoil = IfcCoilTypeEnum.GASHEATINGCOIL + + +hydroniccoil = IfcCoilTypeEnum.HYDRONICCOIL + + +steamheatingcoil = IfcCoilTypeEnum.STEAMHEATINGCOIL + + +watercoolingcoil = IfcCoilTypeEnum.WATERCOOLINGCOIL + + +waterheatingcoil = IfcCoilTypeEnum.WATERHEATINGCOIL + + +userdefined = IfcCoilTypeEnum.USERDEFINED + + +notdefined = IfcCoilTypeEnum.NOTDEFINED + + +IfcColumnTypeEnum = enum_namespace() + + +column = IfcColumnTypeEnum.COLUMN + + +pilaster = IfcColumnTypeEnum.PILASTER + + +pierstem = IfcColumnTypeEnum.PIERSTEM + + +pierstem_segment = IfcColumnTypeEnum.PIERSTEM_SEGMENT + + +standcolumn = IfcColumnTypeEnum.STANDCOLUMN + + +userdefined = IfcColumnTypeEnum.USERDEFINED + + +notdefined = IfcColumnTypeEnum.NOTDEFINED + + +IfcCommunicationsApplianceTypeEnum = enum_namespace() + + +antenna = IfcCommunicationsApplianceTypeEnum.ANTENNA + + +computer = IfcCommunicationsApplianceTypeEnum.COMPUTER + + +fax = IfcCommunicationsApplianceTypeEnum.FAX + + +gateway = IfcCommunicationsApplianceTypeEnum.GATEWAY + + +modem = IfcCommunicationsApplianceTypeEnum.MODEM + + +networkappliance = IfcCommunicationsApplianceTypeEnum.NETWORKAPPLIANCE + + +networkbridge = IfcCommunicationsApplianceTypeEnum.NETWORKBRIDGE + + +networkhub = IfcCommunicationsApplianceTypeEnum.NETWORKHUB + + +printer = IfcCommunicationsApplianceTypeEnum.PRINTER + + +repeater = IfcCommunicationsApplianceTypeEnum.REPEATER + + +router = IfcCommunicationsApplianceTypeEnum.ROUTER + + +scanner = IfcCommunicationsApplianceTypeEnum.SCANNER + + +automaton = IfcCommunicationsApplianceTypeEnum.AUTOMATON + + +intelligent_peripheral = IfcCommunicationsApplianceTypeEnum.INTELLIGENT_PERIPHERAL + + +ip_network_equipment = IfcCommunicationsApplianceTypeEnum.IP_NETWORK_EQUIPMENT + + +optical_network_unit = IfcCommunicationsApplianceTypeEnum.OPTICAL_NETWORK_UNIT + + +telecommand = IfcCommunicationsApplianceTypeEnum.TELECOMMAND + + +telephonyexchange = IfcCommunicationsApplianceTypeEnum.TELEPHONYEXCHANGE + + +transitioncomponent = IfcCommunicationsApplianceTypeEnum.TRANSITIONCOMPONENT + + +transponder = IfcCommunicationsApplianceTypeEnum.TRANSPONDER + + +transportequipment = IfcCommunicationsApplianceTypeEnum.TRANSPORTEQUIPMENT + + +userdefined = IfcCommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcCommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcComplexPropertyTemplateTypeEnum = enum_namespace() + + +p_complex = IfcComplexPropertyTemplateTypeEnum.P_COMPLEX + + +q_complex = IfcComplexPropertyTemplateTypeEnum.Q_COMPLEX + + +IfcCompressorTypeEnum = enum_namespace() + + +dynamic = IfcCompressorTypeEnum.DYNAMIC + + +reciprocating = IfcCompressorTypeEnum.RECIPROCATING + + +rotary = IfcCompressorTypeEnum.ROTARY + + +scroll = IfcCompressorTypeEnum.SCROLL + + +trochoidal = IfcCompressorTypeEnum.TROCHOIDAL + + +singlestage = IfcCompressorTypeEnum.SINGLESTAGE + + +booster = IfcCompressorTypeEnum.BOOSTER + + +opentype = IfcCompressorTypeEnum.OPENTYPE + + +hermetic = IfcCompressorTypeEnum.HERMETIC + + +semihermetic = IfcCompressorTypeEnum.SEMIHERMETIC + + +weldedshellhermetic = IfcCompressorTypeEnum.WELDEDSHELLHERMETIC + + +rollingpiston = IfcCompressorTypeEnum.ROLLINGPISTON + + +rotaryvane = IfcCompressorTypeEnum.ROTARYVANE + + +singlescrew = IfcCompressorTypeEnum.SINGLESCREW + + +twinscrew = IfcCompressorTypeEnum.TWINSCREW + + +userdefined = IfcCompressorTypeEnum.USERDEFINED + + +notdefined = IfcCompressorTypeEnum.NOTDEFINED + + +IfcCondenserTypeEnum = enum_namespace() + + +aircooled = IfcCondenserTypeEnum.AIRCOOLED + + +evaporativecooled = IfcCondenserTypeEnum.EVAPORATIVECOOLED + + +watercooled = IfcCondenserTypeEnum.WATERCOOLED + + +watercooledbrazedplate = IfcCondenserTypeEnum.WATERCOOLEDBRAZEDPLATE + + +watercooledshellcoil = IfcCondenserTypeEnum.WATERCOOLEDSHELLCOIL + + +watercooledshelltube = IfcCondenserTypeEnum.WATERCOOLEDSHELLTUBE + + +watercooledtubeintube = IfcCondenserTypeEnum.WATERCOOLEDTUBEINTUBE + + +userdefined = IfcCondenserTypeEnum.USERDEFINED + + +notdefined = IfcCondenserTypeEnum.NOTDEFINED + + +IfcConnectionTypeEnum = enum_namespace() + + +atpath = IfcConnectionTypeEnum.ATPATH + + +atstart = IfcConnectionTypeEnum.ATSTART + + +atend = IfcConnectionTypeEnum.ATEND + + +notdefined = IfcConnectionTypeEnum.NOTDEFINED + + +IfcConstraintEnum = enum_namespace() + + +hard = IfcConstraintEnum.HARD + + +soft = IfcConstraintEnum.SOFT + + +advisory = IfcConstraintEnum.ADVISORY + + +userdefined = IfcConstraintEnum.USERDEFINED + + +notdefined = IfcConstraintEnum.NOTDEFINED + + +IfcConstructionEquipmentResourceTypeEnum = enum_namespace() + + +demolishing = IfcConstructionEquipmentResourceTypeEnum.DEMOLISHING + + +earthmoving = IfcConstructionEquipmentResourceTypeEnum.EARTHMOVING + + +erecting = IfcConstructionEquipmentResourceTypeEnum.ERECTING + + +heating = IfcConstructionEquipmentResourceTypeEnum.HEATING + + +lighting = IfcConstructionEquipmentResourceTypeEnum.LIGHTING + + +paving = IfcConstructionEquipmentResourceTypeEnum.PAVING + + +pumping = IfcConstructionEquipmentResourceTypeEnum.PUMPING + + +transporting = IfcConstructionEquipmentResourceTypeEnum.TRANSPORTING + + +userdefined = IfcConstructionEquipmentResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionEquipmentResourceTypeEnum.NOTDEFINED + + +IfcConstructionMaterialResourceTypeEnum = enum_namespace() + + +aggregates = IfcConstructionMaterialResourceTypeEnum.AGGREGATES + + +concrete = IfcConstructionMaterialResourceTypeEnum.CONCRETE + + +drywall = IfcConstructionMaterialResourceTypeEnum.DRYWALL + + +fuel = IfcConstructionMaterialResourceTypeEnum.FUEL + + +gypsum = IfcConstructionMaterialResourceTypeEnum.GYPSUM + + +masonry = IfcConstructionMaterialResourceTypeEnum.MASONRY + + +metal = IfcConstructionMaterialResourceTypeEnum.METAL + + +plastic = IfcConstructionMaterialResourceTypeEnum.PLASTIC + + +wood = IfcConstructionMaterialResourceTypeEnum.WOOD + + +notdefined = IfcConstructionMaterialResourceTypeEnum.NOTDEFINED + + +userdefined = IfcConstructionMaterialResourceTypeEnum.USERDEFINED + + +IfcConstructionProductResourceTypeEnum = enum_namespace() + + +assembly = IfcConstructionProductResourceTypeEnum.ASSEMBLY + + +formwork = IfcConstructionProductResourceTypeEnum.FORMWORK + + +userdefined = IfcConstructionProductResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionProductResourceTypeEnum.NOTDEFINED + + +IfcControllerTypeEnum = enum_namespace() + + +floating = IfcControllerTypeEnum.FLOATING + + +programmable = IfcControllerTypeEnum.PROGRAMMABLE + + +proportional = IfcControllerTypeEnum.PROPORTIONAL + + +multiposition = IfcControllerTypeEnum.MULTIPOSITION + + +twoposition = IfcControllerTypeEnum.TWOPOSITION + + +userdefined = IfcControllerTypeEnum.USERDEFINED + + +notdefined = IfcControllerTypeEnum.NOTDEFINED + + +IfcConveyorSegmentTypeEnum = enum_namespace() + + +chuteconveyor = IfcConveyorSegmentTypeEnum.CHUTECONVEYOR + + +beltconveyor = IfcConveyorSegmentTypeEnum.BELTCONVEYOR + + +screwconveyor = IfcConveyorSegmentTypeEnum.SCREWCONVEYOR + + +bucketconveyor = IfcConveyorSegmentTypeEnum.BUCKETCONVEYOR + + +userdefined = IfcConveyorSegmentTypeEnum.USERDEFINED + + +notdefined = IfcConveyorSegmentTypeEnum.NOTDEFINED + + +IfcCooledBeamTypeEnum = enum_namespace() + + +active = IfcCooledBeamTypeEnum.ACTIVE + + +passive = IfcCooledBeamTypeEnum.PASSIVE + + +userdefined = IfcCooledBeamTypeEnum.USERDEFINED + + +notdefined = IfcCooledBeamTypeEnum.NOTDEFINED + + +IfcCoolingTowerTypeEnum = enum_namespace() + + +naturaldraft = IfcCoolingTowerTypeEnum.NATURALDRAFT + + +mechanicalinduceddraft = IfcCoolingTowerTypeEnum.MECHANICALINDUCEDDRAFT + + +mechanicalforceddraft = IfcCoolingTowerTypeEnum.MECHANICALFORCEDDRAFT + + +userdefined = IfcCoolingTowerTypeEnum.USERDEFINED + + +notdefined = IfcCoolingTowerTypeEnum.NOTDEFINED + + +IfcCostItemTypeEnum = enum_namespace() + + +userdefined = IfcCostItemTypeEnum.USERDEFINED + + +notdefined = IfcCostItemTypeEnum.NOTDEFINED + + +IfcCostScheduleTypeEnum = enum_namespace() + + +budget = IfcCostScheduleTypeEnum.BUDGET + + +costplan = IfcCostScheduleTypeEnum.COSTPLAN + + +estimate = IfcCostScheduleTypeEnum.ESTIMATE + + +tender = IfcCostScheduleTypeEnum.TENDER + + +pricedbillofquantities = IfcCostScheduleTypeEnum.PRICEDBILLOFQUANTITIES + + +unpricedbillofquantities = IfcCostScheduleTypeEnum.UNPRICEDBILLOFQUANTITIES + + +scheduleofrates = IfcCostScheduleTypeEnum.SCHEDULEOFRATES + + +userdefined = IfcCostScheduleTypeEnum.USERDEFINED + + +notdefined = IfcCostScheduleTypeEnum.NOTDEFINED + + +IfcCourseTypeEnum = enum_namespace() + + +armour = IfcCourseTypeEnum.ARMOUR + + +filter = IfcCourseTypeEnum.FILTER + + +ballastbed = IfcCourseTypeEnum.BALLASTBED + + +core = IfcCourseTypeEnum.CORE + + +pavement = IfcCourseTypeEnum.PAVEMENT + + +protection = IfcCourseTypeEnum.PROTECTION + + +userdefined = IfcCourseTypeEnum.USERDEFINED + + +notdefined = IfcCourseTypeEnum.NOTDEFINED + + +IfcCoveringTypeEnum = enum_namespace() + + +ceiling = IfcCoveringTypeEnum.CEILING + + +flooring = IfcCoveringTypeEnum.FLOORING + + +cladding = IfcCoveringTypeEnum.CLADDING + + +roofing = IfcCoveringTypeEnum.ROOFING + + +molding = IfcCoveringTypeEnum.MOLDING + + +skirtingboard = IfcCoveringTypeEnum.SKIRTINGBOARD + + +insulation = IfcCoveringTypeEnum.INSULATION + + +membrane = IfcCoveringTypeEnum.MEMBRANE + + +sleeving = IfcCoveringTypeEnum.SLEEVING + + +wrapping = IfcCoveringTypeEnum.WRAPPING + + +coping = IfcCoveringTypeEnum.COPING + + +userdefined = IfcCoveringTypeEnum.USERDEFINED + + +notdefined = IfcCoveringTypeEnum.NOTDEFINED + + +IfcCrewResourceTypeEnum = enum_namespace() + + +office = IfcCrewResourceTypeEnum.OFFICE + + +site = IfcCrewResourceTypeEnum.SITE + + +userdefined = IfcCrewResourceTypeEnum.USERDEFINED + + +notdefined = IfcCrewResourceTypeEnum.NOTDEFINED + + +IfcCurtainWallTypeEnum = enum_namespace() + + +userdefined = IfcCurtainWallTypeEnum.USERDEFINED + + +notdefined = IfcCurtainWallTypeEnum.NOTDEFINED + + +IfcCurveInterpolationEnum = enum_namespace() + + +linear = IfcCurveInterpolationEnum.LINEAR + + +log_linear = IfcCurveInterpolationEnum.LOG_LINEAR + + +log_log = IfcCurveInterpolationEnum.LOG_LOG + + +notdefined = IfcCurveInterpolationEnum.NOTDEFINED + + +IfcDamperTypeEnum = enum_namespace() + + +backdraftdamper = IfcDamperTypeEnum.BACKDRAFTDAMPER + + +balancingdamper = IfcDamperTypeEnum.BALANCINGDAMPER + + +blastdamper = IfcDamperTypeEnum.BLASTDAMPER + + +controldamper = IfcDamperTypeEnum.CONTROLDAMPER + + +firedamper = IfcDamperTypeEnum.FIREDAMPER + + +firesmokedamper = IfcDamperTypeEnum.FIRESMOKEDAMPER + + +fumehoodexhaust = IfcDamperTypeEnum.FUMEHOODEXHAUST + + +gravitydamper = IfcDamperTypeEnum.GRAVITYDAMPER + + +gravityreliefdamper = IfcDamperTypeEnum.GRAVITYRELIEFDAMPER + + +reliefdamper = IfcDamperTypeEnum.RELIEFDAMPER + + +smokedamper = IfcDamperTypeEnum.SMOKEDAMPER + + +userdefined = IfcDamperTypeEnum.USERDEFINED + + +notdefined = IfcDamperTypeEnum.NOTDEFINED + + +IfcDataOriginEnum = enum_namespace() + + +measured = IfcDataOriginEnum.MEASURED + + +predicted = IfcDataOriginEnum.PREDICTED + + +simulated = IfcDataOriginEnum.SIMULATED + + +userdefined = IfcDataOriginEnum.USERDEFINED + + +notdefined = IfcDataOriginEnum.NOTDEFINED + + +IfcDerivedUnitEnum = enum_namespace() + + +angularvelocityunit = IfcDerivedUnitEnum.ANGULARVELOCITYUNIT + + +areadensityunit = IfcDerivedUnitEnum.AREADENSITYUNIT + + +compoundplaneangleunit = IfcDerivedUnitEnum.COMPOUNDPLANEANGLEUNIT + + +dynamicviscosityunit = IfcDerivedUnitEnum.DYNAMICVISCOSITYUNIT + + +heatfluxdensityunit = IfcDerivedUnitEnum.HEATFLUXDENSITYUNIT + + +integercountrateunit = IfcDerivedUnitEnum.INTEGERCOUNTRATEUNIT + + +isothermalmoisturecapacityunit = IfcDerivedUnitEnum.ISOTHERMALMOISTURECAPACITYUNIT + + +kinematicviscosityunit = IfcDerivedUnitEnum.KINEMATICVISCOSITYUNIT + + +linearvelocityunit = IfcDerivedUnitEnum.LINEARVELOCITYUNIT + + +massdensityunit = IfcDerivedUnitEnum.MASSDENSITYUNIT + + +massflowrateunit = IfcDerivedUnitEnum.MASSFLOWRATEUNIT + + +moisturediffusivityunit = IfcDerivedUnitEnum.MOISTUREDIFFUSIVITYUNIT + + +molecularweightunit = IfcDerivedUnitEnum.MOLECULARWEIGHTUNIT + + +specificheatcapacityunit = IfcDerivedUnitEnum.SPECIFICHEATCAPACITYUNIT + + +thermaladmittanceunit = IfcDerivedUnitEnum.THERMALADMITTANCEUNIT + + +thermalconductanceunit = IfcDerivedUnitEnum.THERMALCONDUCTANCEUNIT + + +thermalresistanceunit = IfcDerivedUnitEnum.THERMALRESISTANCEUNIT + + +thermaltransmittanceunit = IfcDerivedUnitEnum.THERMALTRANSMITTANCEUNIT + + +vaporpermeabilityunit = IfcDerivedUnitEnum.VAPORPERMEABILITYUNIT + + +volumetricflowrateunit = IfcDerivedUnitEnum.VOLUMETRICFLOWRATEUNIT + + +rotationalfrequencyunit = IfcDerivedUnitEnum.ROTATIONALFREQUENCYUNIT + + +torqueunit = IfcDerivedUnitEnum.TORQUEUNIT + + +momentofinertiaunit = IfcDerivedUnitEnum.MOMENTOFINERTIAUNIT + + +linearmomentunit = IfcDerivedUnitEnum.LINEARMOMENTUNIT + + +linearforceunit = IfcDerivedUnitEnum.LINEARFORCEUNIT + + +planarforceunit = IfcDerivedUnitEnum.PLANARFORCEUNIT + + +modulusofelasticityunit = IfcDerivedUnitEnum.MODULUSOFELASTICITYUNIT + + +shearmodulusunit = IfcDerivedUnitEnum.SHEARMODULUSUNIT + + +linearstiffnessunit = IfcDerivedUnitEnum.LINEARSTIFFNESSUNIT + + +rotationalstiffnessunit = IfcDerivedUnitEnum.ROTATIONALSTIFFNESSUNIT + + +modulusofsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFSUBGRADEREACTIONUNIT + + +accelerationunit = IfcDerivedUnitEnum.ACCELERATIONUNIT + + +curvatureunit = IfcDerivedUnitEnum.CURVATUREUNIT + + +heatingvalueunit = IfcDerivedUnitEnum.HEATINGVALUEUNIT + + +ionconcentrationunit = IfcDerivedUnitEnum.IONCONCENTRATIONUNIT + + +luminousintensitydistributionunit = IfcDerivedUnitEnum.LUMINOUSINTENSITYDISTRIBUTIONUNIT + + +massperlengthunit = IfcDerivedUnitEnum.MASSPERLENGTHUNIT + + +modulusoflinearsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFLINEARSUBGRADEREACTIONUNIT + + +modulusofrotationalsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFROTATIONALSUBGRADEREACTIONUNIT + + +phunit = IfcDerivedUnitEnum.PHUNIT + + +rotationalmassunit = IfcDerivedUnitEnum.ROTATIONALMASSUNIT + + +sectionareaintegralunit = IfcDerivedUnitEnum.SECTIONAREAINTEGRALUNIT + + +sectionmodulusunit = IfcDerivedUnitEnum.SECTIONMODULUSUNIT + + +soundpowerlevelunit = IfcDerivedUnitEnum.SOUNDPOWERLEVELUNIT + + +soundpowerunit = IfcDerivedUnitEnum.SOUNDPOWERUNIT + + +soundpressurelevelunit = IfcDerivedUnitEnum.SOUNDPRESSURELEVELUNIT + + +soundpressureunit = IfcDerivedUnitEnum.SOUNDPRESSUREUNIT + + +temperaturegradientunit = IfcDerivedUnitEnum.TEMPERATUREGRADIENTUNIT + + +temperaturerateofchangeunit = IfcDerivedUnitEnum.TEMPERATURERATEOFCHANGEUNIT + + +thermalexpansioncoefficientunit = IfcDerivedUnitEnum.THERMALEXPANSIONCOEFFICIENTUNIT + + +warpingconstantunit = IfcDerivedUnitEnum.WARPINGCONSTANTUNIT + + +warpingmomentunit = IfcDerivedUnitEnum.WARPINGMOMENTUNIT + + +userdefined = IfcDerivedUnitEnum.USERDEFINED + + +IfcDirectionSenseEnum = enum_namespace() + + +positive = IfcDirectionSenseEnum.POSITIVE + + +negative = IfcDirectionSenseEnum.NEGATIVE + + +IfcDiscreteAccessoryTypeEnum = enum_namespace() + + +anchorplate = IfcDiscreteAccessoryTypeEnum.ANCHORPLATE + + +bracket = IfcDiscreteAccessoryTypeEnum.BRACKET + + +shoe = IfcDiscreteAccessoryTypeEnum.SHOE + + +expansion_joint_device = IfcDiscreteAccessoryTypeEnum.EXPANSION_JOINT_DEVICE + + +cablearranger = IfcDiscreteAccessoryTypeEnum.CABLEARRANGER + + +insulator = IfcDiscreteAccessoryTypeEnum.INSULATOR + + +lock = IfcDiscreteAccessoryTypeEnum.LOCK + + +tensioningequipment = IfcDiscreteAccessoryTypeEnum.TENSIONINGEQUIPMENT + + +railpad = IfcDiscreteAccessoryTypeEnum.RAILPAD + + +slidingchair = IfcDiscreteAccessoryTypeEnum.SLIDINGCHAIR + + +rail_lubrication = IfcDiscreteAccessoryTypeEnum.RAIL_LUBRICATION + + +panel_strengthening = IfcDiscreteAccessoryTypeEnum.PANEL_STRENGTHENING + + +railbrace = IfcDiscreteAccessoryTypeEnum.RAILBRACE + + +elastic_cushion = IfcDiscreteAccessoryTypeEnum.ELASTIC_CUSHION + + +soundabsorption = IfcDiscreteAccessoryTypeEnum.SOUNDABSORPTION + + +pointmachinemountingdevice = IfcDiscreteAccessoryTypeEnum.POINTMACHINEMOUNTINGDEVICE + + +point_machine_locking_device = IfcDiscreteAccessoryTypeEnum.POINT_MACHINE_LOCKING_DEVICE + + +rail_mechanical_equipment = IfcDiscreteAccessoryTypeEnum.RAIL_MECHANICAL_EQUIPMENT + + +birdprotection = IfcDiscreteAccessoryTypeEnum.BIRDPROTECTION + + +userdefined = IfcDiscreteAccessoryTypeEnum.USERDEFINED + + +notdefined = IfcDiscreteAccessoryTypeEnum.NOTDEFINED + + +IfcDistributionBoardTypeEnum = enum_namespace() + + +switchboard = IfcDistributionBoardTypeEnum.SWITCHBOARD + + +consumerunit = IfcDistributionBoardTypeEnum.CONSUMERUNIT + + +motorcontrolcentre = IfcDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +distributionframe = IfcDistributionBoardTypeEnum.DISTRIBUTIONFRAME + + +distributionboard = IfcDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +userdefined = IfcDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcDistributionBoardTypeEnum.NOTDEFINED + + +IfcDistributionChamberElementTypeEnum = enum_namespace() + + +formedduct = IfcDistributionChamberElementTypeEnum.FORMEDDUCT + + +inspectionchamber = IfcDistributionChamberElementTypeEnum.INSPECTIONCHAMBER + + +inspectionpit = IfcDistributionChamberElementTypeEnum.INSPECTIONPIT + + +manhole = IfcDistributionChamberElementTypeEnum.MANHOLE + + +meterchamber = IfcDistributionChamberElementTypeEnum.METERCHAMBER + + +sump = IfcDistributionChamberElementTypeEnum.SUMP + + +trench = IfcDistributionChamberElementTypeEnum.TRENCH + + +valvechamber = IfcDistributionChamberElementTypeEnum.VALVECHAMBER + + +userdefined = IfcDistributionChamberElementTypeEnum.USERDEFINED + + +notdefined = IfcDistributionChamberElementTypeEnum.NOTDEFINED + + +IfcDistributionPortTypeEnum = enum_namespace() + + +cable = IfcDistributionPortTypeEnum.CABLE + + +cablecarrier = IfcDistributionPortTypeEnum.CABLECARRIER + + +duct = IfcDistributionPortTypeEnum.DUCT + + +pipe = IfcDistributionPortTypeEnum.PIPE + + +wireless = IfcDistributionPortTypeEnum.WIRELESS + + +userdefined = IfcDistributionPortTypeEnum.USERDEFINED + + +notdefined = IfcDistributionPortTypeEnum.NOTDEFINED + + +IfcDistributionSystemEnum = enum_namespace() + + +airconditioning = IfcDistributionSystemEnum.AIRCONDITIONING + + +audiovisual = IfcDistributionSystemEnum.AUDIOVISUAL + + +chemical = IfcDistributionSystemEnum.CHEMICAL + + +chilledwater = IfcDistributionSystemEnum.CHILLEDWATER + + +communication = IfcDistributionSystemEnum.COMMUNICATION + + +compressedair = IfcDistributionSystemEnum.COMPRESSEDAIR + + +condenserwater = IfcDistributionSystemEnum.CONDENSERWATER + + +control = IfcDistributionSystemEnum.CONTROL + + +conveying = IfcDistributionSystemEnum.CONVEYING + + +data = IfcDistributionSystemEnum.DATA + + +disposal = IfcDistributionSystemEnum.DISPOSAL + + +domesticcoldwater = IfcDistributionSystemEnum.DOMESTICCOLDWATER + + +domestichotwater = IfcDistributionSystemEnum.DOMESTICHOTWATER + + +drainage = IfcDistributionSystemEnum.DRAINAGE + + +earthing = IfcDistributionSystemEnum.EARTHING + + +electrical = IfcDistributionSystemEnum.ELECTRICAL + + +electroacoustic = IfcDistributionSystemEnum.ELECTROACOUSTIC + + +exhaust = IfcDistributionSystemEnum.EXHAUST + + +fireprotection = IfcDistributionSystemEnum.FIREPROTECTION + + +fuel = IfcDistributionSystemEnum.FUEL + + +gas = IfcDistributionSystemEnum.GAS + + +hazardous = IfcDistributionSystemEnum.HAZARDOUS + + +heating = IfcDistributionSystemEnum.HEATING + + +lighting = IfcDistributionSystemEnum.LIGHTING + + +lightningprotection = IfcDistributionSystemEnum.LIGHTNINGPROTECTION + + +municipalsolidwaste = IfcDistributionSystemEnum.MUNICIPALSOLIDWASTE + + +oil = IfcDistributionSystemEnum.OIL + + +operational = IfcDistributionSystemEnum.OPERATIONAL + + +powergeneration = IfcDistributionSystemEnum.POWERGENERATION + + +rainwater = IfcDistributionSystemEnum.RAINWATER + + +refrigeration = IfcDistributionSystemEnum.REFRIGERATION + + +security = IfcDistributionSystemEnum.SECURITY + + +sewage = IfcDistributionSystemEnum.SEWAGE + + +signal = IfcDistributionSystemEnum.SIGNAL + + +stormwater = IfcDistributionSystemEnum.STORMWATER + + +telephone = IfcDistributionSystemEnum.TELEPHONE + + +tv = IfcDistributionSystemEnum.TV + + +vacuum = IfcDistributionSystemEnum.VACUUM + + +vent = IfcDistributionSystemEnum.VENT + + +ventilation = IfcDistributionSystemEnum.VENTILATION + + +wastewater = IfcDistributionSystemEnum.WASTEWATER + + +watersupply = IfcDistributionSystemEnum.WATERSUPPLY + + +catenary_system = IfcDistributionSystemEnum.CATENARY_SYSTEM + + +overhead_contactline_system = IfcDistributionSystemEnum.OVERHEAD_CONTACTLINE_SYSTEM + + +return_circuit = IfcDistributionSystemEnum.RETURN_CIRCUIT + + +userdefined = IfcDistributionSystemEnum.USERDEFINED + + +notdefined = IfcDistributionSystemEnum.NOTDEFINED + + +IfcDocumentConfidentialityEnum = enum_namespace() + + +public = IfcDocumentConfidentialityEnum.PUBLIC + + +restricted = IfcDocumentConfidentialityEnum.RESTRICTED + + +confidential = IfcDocumentConfidentialityEnum.CONFIDENTIAL + + +personal = IfcDocumentConfidentialityEnum.PERSONAL + + +userdefined = IfcDocumentConfidentialityEnum.USERDEFINED + + +notdefined = IfcDocumentConfidentialityEnum.NOTDEFINED + + +IfcDocumentStatusEnum = enum_namespace() + + +draft = IfcDocumentStatusEnum.DRAFT + + +finaldraft = IfcDocumentStatusEnum.FINALDRAFT + + +final = IfcDocumentStatusEnum.FINAL + + +revision = IfcDocumentStatusEnum.REVISION + + +notdefined = IfcDocumentStatusEnum.NOTDEFINED + + +IfcDoorPanelOperationEnum = enum_namespace() + + +swinging = IfcDoorPanelOperationEnum.SWINGING + + +double_acting = IfcDoorPanelOperationEnum.DOUBLE_ACTING + + +sliding = IfcDoorPanelOperationEnum.SLIDING + + +folding = IfcDoorPanelOperationEnum.FOLDING + + +revolving = IfcDoorPanelOperationEnum.REVOLVING + + +rollingup = IfcDoorPanelOperationEnum.ROLLINGUP + + +fixedpanel = IfcDoorPanelOperationEnum.FIXEDPANEL + + +userdefined = IfcDoorPanelOperationEnum.USERDEFINED + + +notdefined = IfcDoorPanelOperationEnum.NOTDEFINED + + +IfcDoorPanelPositionEnum = enum_namespace() + + +left = IfcDoorPanelPositionEnum.LEFT + + +middle = IfcDoorPanelPositionEnum.MIDDLE + + +right = IfcDoorPanelPositionEnum.RIGHT + + +notdefined = IfcDoorPanelPositionEnum.NOTDEFINED + + +IfcDoorStyleConstructionEnum = enum_namespace() + + +aluminium = IfcDoorStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcDoorStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcDoorStyleConstructionEnum.STEEL + + +wood = IfcDoorStyleConstructionEnum.WOOD + + +aluminium_wood = IfcDoorStyleConstructionEnum.ALUMINIUM_WOOD + + +aluminium_plastic = IfcDoorStyleConstructionEnum.ALUMINIUM_PLASTIC + + +plastic = IfcDoorStyleConstructionEnum.PLASTIC + + +userdefined = IfcDoorStyleConstructionEnum.USERDEFINED + + +notdefined = IfcDoorStyleConstructionEnum.NOTDEFINED + + +IfcDoorStyleOperationEnum = enum_namespace() + + +single_swing_left = IfcDoorStyleOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorStyleOperationEnum.SINGLE_SWING_RIGHT + + +double_door_single_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_swing_left = IfcDoorStyleOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorStyleOperationEnum.DOUBLE_SWING_RIGHT + + +double_door_double_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +sliding_to_left = IfcDoorStyleOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorStyleOperationEnum.SLIDING_TO_RIGHT + + +double_door_sliding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SLIDING + + +folding_to_left = IfcDoorStyleOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorStyleOperationEnum.FOLDING_TO_RIGHT + + +double_door_folding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_FOLDING + + +revolving = IfcDoorStyleOperationEnum.REVOLVING + + +rollingup = IfcDoorStyleOperationEnum.ROLLINGUP + + +userdefined = IfcDoorStyleOperationEnum.USERDEFINED + + +notdefined = IfcDoorStyleOperationEnum.NOTDEFINED + + +IfcDoorTypeEnum = enum_namespace() + + +door = IfcDoorTypeEnum.DOOR + + +gate = IfcDoorTypeEnum.GATE + + +trapdoor = IfcDoorTypeEnum.TRAPDOOR + + +boom_barrier = IfcDoorTypeEnum.BOOM_BARRIER + + +turnstile = IfcDoorTypeEnum.TURNSTILE + + +userdefined = IfcDoorTypeEnum.USERDEFINED + + +notdefined = IfcDoorTypeEnum.NOTDEFINED + + +IfcDoorTypeOperationEnum = enum_namespace() + + +single_swing_left = IfcDoorTypeOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorTypeOperationEnum.SINGLE_SWING_RIGHT + + +double_panel_single_swing = IfcDoorTypeOperationEnum.DOUBLE_PANEL_SINGLE_SWING + + +double_panel_single_swing_opposite_left = IfcDoorTypeOperationEnum.DOUBLE_PANEL_SINGLE_SWING_OPPOSITE_LEFT + + +double_panel_single_swing_opposite_right = IfcDoorTypeOperationEnum.DOUBLE_PANEL_SINGLE_SWING_OPPOSITE_RIGHT + + +double_swing_left = IfcDoorTypeOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorTypeOperationEnum.DOUBLE_SWING_RIGHT + + +double_panel_double_swing = IfcDoorTypeOperationEnum.DOUBLE_PANEL_DOUBLE_SWING + + +sliding_to_left = IfcDoorTypeOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorTypeOperationEnum.SLIDING_TO_RIGHT + + +double_panel_sliding = IfcDoorTypeOperationEnum.DOUBLE_PANEL_SLIDING + + +folding_to_left = IfcDoorTypeOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorTypeOperationEnum.FOLDING_TO_RIGHT + + +double_panel_folding = IfcDoorTypeOperationEnum.DOUBLE_PANEL_FOLDING + + +revolving_horizontal = IfcDoorTypeOperationEnum.REVOLVING_HORIZONTAL + + +rollingup = IfcDoorTypeOperationEnum.ROLLINGUP + + +swing_fixed_left = IfcDoorTypeOperationEnum.SWING_FIXED_LEFT + + +swing_fixed_right = IfcDoorTypeOperationEnum.SWING_FIXED_RIGHT + + +double_panel_lifting_vertical = IfcDoorTypeOperationEnum.DOUBLE_PANEL_LIFTING_VERTICAL + + +lifting_horizontal = IfcDoorTypeOperationEnum.LIFTING_HORIZONTAL + + +lifting_vertical_left = IfcDoorTypeOperationEnum.LIFTING_VERTICAL_LEFT + + +lifting_vertical_right = IfcDoorTypeOperationEnum.LIFTING_VERTICAL_RIGHT + + +revolving_vertical = IfcDoorTypeOperationEnum.REVOLVING_VERTICAL + + +userdefined = IfcDoorTypeOperationEnum.USERDEFINED + + +notdefined = IfcDoorTypeOperationEnum.NOTDEFINED + + +IfcDuctFittingTypeEnum = enum_namespace() + + +bend = IfcDuctFittingTypeEnum.BEND + + +connector = IfcDuctFittingTypeEnum.CONNECTOR + + +entry = IfcDuctFittingTypeEnum.ENTRY + + +exit = IfcDuctFittingTypeEnum.EXIT + + +junction = IfcDuctFittingTypeEnum.JUNCTION + + +obstruction = IfcDuctFittingTypeEnum.OBSTRUCTION + + +transition = IfcDuctFittingTypeEnum.TRANSITION + + +userdefined = IfcDuctFittingTypeEnum.USERDEFINED + + +notdefined = IfcDuctFittingTypeEnum.NOTDEFINED + + +IfcDuctSegmentTypeEnum = enum_namespace() + + +rigidsegment = IfcDuctSegmentTypeEnum.RIGIDSEGMENT + + +flexiblesegment = IfcDuctSegmentTypeEnum.FLEXIBLESEGMENT + + +userdefined = IfcDuctSegmentTypeEnum.USERDEFINED + + +notdefined = IfcDuctSegmentTypeEnum.NOTDEFINED + + +IfcDuctSilencerTypeEnum = enum_namespace() + + +flatoval = IfcDuctSilencerTypeEnum.FLATOVAL + + +rectangular = IfcDuctSilencerTypeEnum.RECTANGULAR + + +round = IfcDuctSilencerTypeEnum.ROUND + + +userdefined = IfcDuctSilencerTypeEnum.USERDEFINED + + +notdefined = IfcDuctSilencerTypeEnum.NOTDEFINED + + +IfcEarthworksCutTypeEnum = enum_namespace() + + +trench = IfcEarthworksCutTypeEnum.TRENCH + + +dredging = IfcEarthworksCutTypeEnum.DREDGING + + +excavation = IfcEarthworksCutTypeEnum.EXCAVATION + + +overexcavation = IfcEarthworksCutTypeEnum.OVEREXCAVATION + + +topsoilremoval = IfcEarthworksCutTypeEnum.TOPSOILREMOVAL + + +stepexcavation = IfcEarthworksCutTypeEnum.STEPEXCAVATION + + +pavementmilling = IfcEarthworksCutTypeEnum.PAVEMENTMILLING + + +cut = IfcEarthworksCutTypeEnum.CUT + + +base_excavation = IfcEarthworksCutTypeEnum.BASE_EXCAVATION + + +userdefined = IfcEarthworksCutTypeEnum.USERDEFINED + + +notdefined = IfcEarthworksCutTypeEnum.NOTDEFINED + + +IfcEarthworksFillTypeEnum = enum_namespace() + + +backfill = IfcEarthworksFillTypeEnum.BACKFILL + + +counterweight = IfcEarthworksFillTypeEnum.COUNTERWEIGHT + + +subgrade = IfcEarthworksFillTypeEnum.SUBGRADE + + +embankment = IfcEarthworksFillTypeEnum.EMBANKMENT + + +transitionsection = IfcEarthworksFillTypeEnum.TRANSITIONSECTION + + +subgradebed = IfcEarthworksFillTypeEnum.SUBGRADEBED + + +slopefill = IfcEarthworksFillTypeEnum.SLOPEFILL + + +userdefined = IfcEarthworksFillTypeEnum.USERDEFINED + + +notdefined = IfcEarthworksFillTypeEnum.NOTDEFINED + + +IfcElectricApplianceTypeEnum = enum_namespace() + + +dishwasher = IfcElectricApplianceTypeEnum.DISHWASHER + + +electriccooker = IfcElectricApplianceTypeEnum.ELECTRICCOOKER + + +freestandingelectricheater = IfcElectricApplianceTypeEnum.FREESTANDINGELECTRICHEATER + + +freestandingfan = IfcElectricApplianceTypeEnum.FREESTANDINGFAN + + +freestandingwaterheater = IfcElectricApplianceTypeEnum.FREESTANDINGWATERHEATER + + +freestandingwatercooler = IfcElectricApplianceTypeEnum.FREESTANDINGWATERCOOLER + + +freezer = IfcElectricApplianceTypeEnum.FREEZER + + +fridge_freezer = IfcElectricApplianceTypeEnum.FRIDGE_FREEZER + + +handdryer = IfcElectricApplianceTypeEnum.HANDDRYER + + +kitchenmachine = IfcElectricApplianceTypeEnum.KITCHENMACHINE + + +microwave = IfcElectricApplianceTypeEnum.MICROWAVE + + +photocopier = IfcElectricApplianceTypeEnum.PHOTOCOPIER + + +refrigerator = IfcElectricApplianceTypeEnum.REFRIGERATOR + + +tumbledryer = IfcElectricApplianceTypeEnum.TUMBLEDRYER + + +vendingmachine = IfcElectricApplianceTypeEnum.VENDINGMACHINE + + +washingmachine = IfcElectricApplianceTypeEnum.WASHINGMACHINE + + +userdefined = IfcElectricApplianceTypeEnum.USERDEFINED + + +notdefined = IfcElectricApplianceTypeEnum.NOTDEFINED + + +IfcElectricDistributionBoardTypeEnum = enum_namespace() + + +consumerunit = IfcElectricDistributionBoardTypeEnum.CONSUMERUNIT + + +distributionboard = IfcElectricDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +motorcontrolcentre = IfcElectricDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +switchboard = IfcElectricDistributionBoardTypeEnum.SWITCHBOARD + + +userdefined = IfcElectricDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcElectricDistributionBoardTypeEnum.NOTDEFINED + + +IfcElectricFlowStorageDeviceTypeEnum = enum_namespace() + + +battery = IfcElectricFlowStorageDeviceTypeEnum.BATTERY + + +capacitorbank = IfcElectricFlowStorageDeviceTypeEnum.CAPACITORBANK + + +harmonicfilter = IfcElectricFlowStorageDeviceTypeEnum.HARMONICFILTER + + +inductorbank = IfcElectricFlowStorageDeviceTypeEnum.INDUCTORBANK + + +ups = IfcElectricFlowStorageDeviceTypeEnum.UPS + + +capacitor = IfcElectricFlowStorageDeviceTypeEnum.CAPACITOR + + +compensator = IfcElectricFlowStorageDeviceTypeEnum.COMPENSATOR + + +inductor = IfcElectricFlowStorageDeviceTypeEnum.INDUCTOR + + +recharger = IfcElectricFlowStorageDeviceTypeEnum.RECHARGER + + +userdefined = IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowStorageDeviceTypeEnum.NOTDEFINED + + +IfcElectricFlowTreatmentDeviceTypeEnum = enum_namespace() + + +electronicfilter = IfcElectricFlowTreatmentDeviceTypeEnum.ELECTRONICFILTER + + +userdefined = IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowTreatmentDeviceTypeEnum.NOTDEFINED + + +IfcElectricGeneratorTypeEnum = enum_namespace() + + +chp = IfcElectricGeneratorTypeEnum.CHP + + +enginegenerator = IfcElectricGeneratorTypeEnum.ENGINEGENERATOR + + +standalone = IfcElectricGeneratorTypeEnum.STANDALONE + + +userdefined = IfcElectricGeneratorTypeEnum.USERDEFINED + + +notdefined = IfcElectricGeneratorTypeEnum.NOTDEFINED + + +IfcElectricMotorTypeEnum = enum_namespace() + + +dc = IfcElectricMotorTypeEnum.DC + + +induction = IfcElectricMotorTypeEnum.INDUCTION + + +polyphase = IfcElectricMotorTypeEnum.POLYPHASE + + +reluctancesynchronous = IfcElectricMotorTypeEnum.RELUCTANCESYNCHRONOUS + + +synchronous = IfcElectricMotorTypeEnum.SYNCHRONOUS + + +userdefined = IfcElectricMotorTypeEnum.USERDEFINED + + +notdefined = IfcElectricMotorTypeEnum.NOTDEFINED + + +IfcElectricTimeControlTypeEnum = enum_namespace() + + +timeclock = IfcElectricTimeControlTypeEnum.TIMECLOCK + + +timedelay = IfcElectricTimeControlTypeEnum.TIMEDELAY + + +relay = IfcElectricTimeControlTypeEnum.RELAY + + +userdefined = IfcElectricTimeControlTypeEnum.USERDEFINED + + +notdefined = IfcElectricTimeControlTypeEnum.NOTDEFINED + + +IfcElementAssemblyTypeEnum = enum_namespace() + + +accessory_assembly = IfcElementAssemblyTypeEnum.ACCESSORY_ASSEMBLY + + +arch = IfcElementAssemblyTypeEnum.ARCH + + +beam_grid = IfcElementAssemblyTypeEnum.BEAM_GRID + + +braced_frame = IfcElementAssemblyTypeEnum.BRACED_FRAME + + +girder = IfcElementAssemblyTypeEnum.GIRDER + + +reinforcement_unit = IfcElementAssemblyTypeEnum.REINFORCEMENT_UNIT + + +rigid_frame = IfcElementAssemblyTypeEnum.RIGID_FRAME + + +slab_field = IfcElementAssemblyTypeEnum.SLAB_FIELD + + +truss = IfcElementAssemblyTypeEnum.TRUSS + + +abutment = IfcElementAssemblyTypeEnum.ABUTMENT + + +pier = IfcElementAssemblyTypeEnum.PIER + + +pylon = IfcElementAssemblyTypeEnum.PYLON + + +cross_bracing = IfcElementAssemblyTypeEnum.CROSS_BRACING + + +deck = IfcElementAssemblyTypeEnum.DECK + + +mast = IfcElementAssemblyTypeEnum.MAST + + +signalassembly = IfcElementAssemblyTypeEnum.SIGNALASSEMBLY + + +grid = IfcElementAssemblyTypeEnum.GRID + + +shelter = IfcElementAssemblyTypeEnum.SHELTER + + +supportingassembly = IfcElementAssemblyTypeEnum.SUPPORTINGASSEMBLY + + +suspensionassembly = IfcElementAssemblyTypeEnum.SUSPENSIONASSEMBLY + + +traction_switching_assembly = IfcElementAssemblyTypeEnum.TRACTION_SWITCHING_ASSEMBLY + + +trackpanel = IfcElementAssemblyTypeEnum.TRACKPANEL + + +turnoutpanel = IfcElementAssemblyTypeEnum.TURNOUTPANEL + + +dilatationpanel = IfcElementAssemblyTypeEnum.DILATATIONPANEL + + +rail_mechanical_equipment_assembly = IfcElementAssemblyTypeEnum.RAIL_MECHANICAL_EQUIPMENT_ASSEMBLY + + +entranceworks = IfcElementAssemblyTypeEnum.ENTRANCEWORKS + + +sumpbuster = IfcElementAssemblyTypeEnum.SUMPBUSTER + + +traffic_calming_device = IfcElementAssemblyTypeEnum.TRAFFIC_CALMING_DEVICE + + +userdefined = IfcElementAssemblyTypeEnum.USERDEFINED + + +notdefined = IfcElementAssemblyTypeEnum.NOTDEFINED + + +IfcElementCompositionEnum = enum_namespace() + + +complex = IfcElementCompositionEnum.COMPLEX + + +element = IfcElementCompositionEnum.ELEMENT + + +partial = IfcElementCompositionEnum.PARTIAL + + +IfcEngineTypeEnum = enum_namespace() + + +externalcombustion = IfcEngineTypeEnum.EXTERNALCOMBUSTION + + +internalcombustion = IfcEngineTypeEnum.INTERNALCOMBUSTION + + +userdefined = IfcEngineTypeEnum.USERDEFINED + + +notdefined = IfcEngineTypeEnum.NOTDEFINED + + +IfcEvaporativeCoolerTypeEnum = enum_namespace() + + +directevaporativerandommediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER + + +directevaporativerigidmediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER + + +directevaporativeslingerspackagedaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER + + +directevaporativepackagedrotaryaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER + + +directevaporativeairwasher = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEAIRWASHER + + +indirectevaporativepackageaircooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEPACKAGEAIRCOOLER + + +indirectevaporativewetcoil = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEWETCOIL + + +indirectevaporativecoolingtowerorcoilcooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER + + +indirectdirectcombination = IfcEvaporativeCoolerTypeEnum.INDIRECTDIRECTCOMBINATION + + +userdefined = IfcEvaporativeCoolerTypeEnum.USERDEFINED + + +notdefined = IfcEvaporativeCoolerTypeEnum.NOTDEFINED + + +IfcEvaporatorTypeEnum = enum_namespace() + + +directexpansion = IfcEvaporatorTypeEnum.DIRECTEXPANSION + + +directexpansionshellandtube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONSHELLANDTUBE + + +directexpansiontubeintube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONTUBEINTUBE + + +directexpansionbrazedplate = IfcEvaporatorTypeEnum.DIRECTEXPANSIONBRAZEDPLATE + + +floodedshellandtube = IfcEvaporatorTypeEnum.FLOODEDSHELLANDTUBE + + +shellandcoil = IfcEvaporatorTypeEnum.SHELLANDCOIL + + +userdefined = IfcEvaporatorTypeEnum.USERDEFINED + + +notdefined = IfcEvaporatorTypeEnum.NOTDEFINED + + +IfcEventTriggerTypeEnum = enum_namespace() + + +eventrule = IfcEventTriggerTypeEnum.EVENTRULE + + +eventmessage = IfcEventTriggerTypeEnum.EVENTMESSAGE + + +eventtime = IfcEventTriggerTypeEnum.EVENTTIME + + +eventcomplex = IfcEventTriggerTypeEnum.EVENTCOMPLEX + + +userdefined = IfcEventTriggerTypeEnum.USERDEFINED + + +notdefined = IfcEventTriggerTypeEnum.NOTDEFINED + + +IfcEventTypeEnum = enum_namespace() + + +startevent = IfcEventTypeEnum.STARTEVENT + + +endevent = IfcEventTypeEnum.ENDEVENT + + +intermediateevent = IfcEventTypeEnum.INTERMEDIATEEVENT + + +userdefined = IfcEventTypeEnum.USERDEFINED + + +notdefined = IfcEventTypeEnum.NOTDEFINED + + +IfcExternalSpatialElementTypeEnum = enum_namespace() + + +external = IfcExternalSpatialElementTypeEnum.EXTERNAL + + +external_earth = IfcExternalSpatialElementTypeEnum.EXTERNAL_EARTH + + +external_water = IfcExternalSpatialElementTypeEnum.EXTERNAL_WATER + + +external_fire = IfcExternalSpatialElementTypeEnum.EXTERNAL_FIRE + + +userdefined = IfcExternalSpatialElementTypeEnum.USERDEFINED + + +notdefined = IfcExternalSpatialElementTypeEnum.NOTDEFINED + + +IfcFacilityPartCommonTypeEnum = enum_namespace() + + +segment = IfcFacilityPartCommonTypeEnum.SEGMENT + + +aboveground = IfcFacilityPartCommonTypeEnum.ABOVEGROUND + + +junction = IfcFacilityPartCommonTypeEnum.JUNCTION + + +levelcrossing = IfcFacilityPartCommonTypeEnum.LEVELCROSSING + + +belowground = IfcFacilityPartCommonTypeEnum.BELOWGROUND + + +substructure = IfcFacilityPartCommonTypeEnum.SUBSTRUCTURE + + +terminal = IfcFacilityPartCommonTypeEnum.TERMINAL + + +superstructure = IfcFacilityPartCommonTypeEnum.SUPERSTRUCTURE + + +userdefined = IfcFacilityPartCommonTypeEnum.USERDEFINED + + +notdefined = IfcFacilityPartCommonTypeEnum.NOTDEFINED + + +IfcFacilityUsageEnum = enum_namespace() + + +lateral = IfcFacilityUsageEnum.LATERAL + + +region = IfcFacilityUsageEnum.REGION + + +vertical = IfcFacilityUsageEnum.VERTICAL + + +longitudinal = IfcFacilityUsageEnum.LONGITUDINAL + + +userdefined = IfcFacilityUsageEnum.USERDEFINED + + +notdefined = IfcFacilityUsageEnum.NOTDEFINED + + +IfcFanTypeEnum = enum_namespace() + + +centrifugalforwardcurved = IfcFanTypeEnum.CENTRIFUGALFORWARDCURVED + + +centrifugalradial = IfcFanTypeEnum.CENTRIFUGALRADIAL + + +centrifugalbackwardinclinedcurved = IfcFanTypeEnum.CENTRIFUGALBACKWARDINCLINEDCURVED + + +centrifugalairfoil = IfcFanTypeEnum.CENTRIFUGALAIRFOIL + + +tubeaxial = IfcFanTypeEnum.TUBEAXIAL + + +vaneaxial = IfcFanTypeEnum.VANEAXIAL + + +propelloraxial = IfcFanTypeEnum.PROPELLORAXIAL + + +userdefined = IfcFanTypeEnum.USERDEFINED + + +notdefined = IfcFanTypeEnum.NOTDEFINED + + +IfcFastenerTypeEnum = enum_namespace() + + +glue = IfcFastenerTypeEnum.GLUE + + +mortar = IfcFastenerTypeEnum.MORTAR + + +weld = IfcFastenerTypeEnum.WELD + + +userdefined = IfcFastenerTypeEnum.USERDEFINED + + +notdefined = IfcFastenerTypeEnum.NOTDEFINED + + +IfcFilterTypeEnum = enum_namespace() + + +airparticlefilter = IfcFilterTypeEnum.AIRPARTICLEFILTER + + +compressedairfilter = IfcFilterTypeEnum.COMPRESSEDAIRFILTER + + +odorfilter = IfcFilterTypeEnum.ODORFILTER + + +oilfilter = IfcFilterTypeEnum.OILFILTER + + +strainer = IfcFilterTypeEnum.STRAINER + + +waterfilter = IfcFilterTypeEnum.WATERFILTER + + +userdefined = IfcFilterTypeEnum.USERDEFINED + + +notdefined = IfcFilterTypeEnum.NOTDEFINED + + +IfcFireSuppressionTerminalTypeEnum = enum_namespace() + + +breechinginlet = IfcFireSuppressionTerminalTypeEnum.BREECHINGINLET + + +firehydrant = IfcFireSuppressionTerminalTypeEnum.FIREHYDRANT + + +hosereel = IfcFireSuppressionTerminalTypeEnum.HOSEREEL + + +sprinkler = IfcFireSuppressionTerminalTypeEnum.SPRINKLER + + +sprinklerdeflector = IfcFireSuppressionTerminalTypeEnum.SPRINKLERDEFLECTOR + + +firemonitor = IfcFireSuppressionTerminalTypeEnum.FIREMONITOR + + +userdefined = IfcFireSuppressionTerminalTypeEnum.USERDEFINED + + +notdefined = IfcFireSuppressionTerminalTypeEnum.NOTDEFINED + + +IfcFlowDirectionEnum = enum_namespace() + + +source = IfcFlowDirectionEnum.SOURCE + + +sink = IfcFlowDirectionEnum.SINK + + +sourceandsink = IfcFlowDirectionEnum.SOURCEANDSINK + + +notdefined = IfcFlowDirectionEnum.NOTDEFINED + + +IfcFlowInstrumentTypeEnum = enum_namespace() + + +pressuregauge = IfcFlowInstrumentTypeEnum.PRESSUREGAUGE + + +thermometer = IfcFlowInstrumentTypeEnum.THERMOMETER + + +ammeter = IfcFlowInstrumentTypeEnum.AMMETER + + +frequencymeter = IfcFlowInstrumentTypeEnum.FREQUENCYMETER + + +powerfactormeter = IfcFlowInstrumentTypeEnum.POWERFACTORMETER + + +phaseanglemeter = IfcFlowInstrumentTypeEnum.PHASEANGLEMETER + + +voltmeter_peak = IfcFlowInstrumentTypeEnum.VOLTMETER_PEAK + + +voltmeter_rms = IfcFlowInstrumentTypeEnum.VOLTMETER_RMS + + +combined = IfcFlowInstrumentTypeEnum.COMBINED + + +voltmeter = IfcFlowInstrumentTypeEnum.VOLTMETER + + +userdefined = IfcFlowInstrumentTypeEnum.USERDEFINED + + +notdefined = IfcFlowInstrumentTypeEnum.NOTDEFINED + + +IfcFlowMeterTypeEnum = enum_namespace() + + +energymeter = IfcFlowMeterTypeEnum.ENERGYMETER + + +gasmeter = IfcFlowMeterTypeEnum.GASMETER + + +oilmeter = IfcFlowMeterTypeEnum.OILMETER + + +watermeter = IfcFlowMeterTypeEnum.WATERMETER + + +userdefined = IfcFlowMeterTypeEnum.USERDEFINED + + +notdefined = IfcFlowMeterTypeEnum.NOTDEFINED + + +IfcFootingTypeEnum = enum_namespace() + + +caisson_foundation = IfcFootingTypeEnum.CAISSON_FOUNDATION + + +footing_beam = IfcFootingTypeEnum.FOOTING_BEAM + + +pad_footing = IfcFootingTypeEnum.PAD_FOOTING + + +pile_cap = IfcFootingTypeEnum.PILE_CAP + + +strip_footing = IfcFootingTypeEnum.STRIP_FOOTING + + +userdefined = IfcFootingTypeEnum.USERDEFINED + + +notdefined = IfcFootingTypeEnum.NOTDEFINED + + +IfcFurnitureTypeEnum = enum_namespace() + + +chair = IfcFurnitureTypeEnum.CHAIR + + +table = IfcFurnitureTypeEnum.TABLE + + +desk = IfcFurnitureTypeEnum.DESK + + +bed = IfcFurnitureTypeEnum.BED + + +filecabinet = IfcFurnitureTypeEnum.FILECABINET + + +shelf = IfcFurnitureTypeEnum.SHELF + + +sofa = IfcFurnitureTypeEnum.SOFA + + +technicalcabinet = IfcFurnitureTypeEnum.TECHNICALCABINET + + +userdefined = IfcFurnitureTypeEnum.USERDEFINED + + +notdefined = IfcFurnitureTypeEnum.NOTDEFINED + + +IfcGeographicElementTypeEnum = enum_namespace() + + +terrain = IfcGeographicElementTypeEnum.TERRAIN + + +soil_boring_point = IfcGeographicElementTypeEnum.SOIL_BORING_POINT + + +userdefined = IfcGeographicElementTypeEnum.USERDEFINED + + +notdefined = IfcGeographicElementTypeEnum.NOTDEFINED + + +IfcGeometricProjectionEnum = enum_namespace() + + +graph_view = IfcGeometricProjectionEnum.GRAPH_VIEW + + +sketch_view = IfcGeometricProjectionEnum.SKETCH_VIEW + + +model_view = IfcGeometricProjectionEnum.MODEL_VIEW + + +plan_view = IfcGeometricProjectionEnum.PLAN_VIEW + + +reflected_plan_view = IfcGeometricProjectionEnum.REFLECTED_PLAN_VIEW + + +section_view = IfcGeometricProjectionEnum.SECTION_VIEW + + +elevation_view = IfcGeometricProjectionEnum.ELEVATION_VIEW + + +userdefined = IfcGeometricProjectionEnum.USERDEFINED + + +notdefined = IfcGeometricProjectionEnum.NOTDEFINED + + +IfcGlobalOrLocalEnum = enum_namespace() + + +global_coords = IfcGlobalOrLocalEnum.GLOBAL_COORDS + + +local_coords = IfcGlobalOrLocalEnum.LOCAL_COORDS + + +IfcGridTypeEnum = enum_namespace() + + +rectangular = IfcGridTypeEnum.RECTANGULAR + + +radial = IfcGridTypeEnum.RADIAL + + +triangular = IfcGridTypeEnum.TRIANGULAR + + +irregular = IfcGridTypeEnum.IRREGULAR + + +userdefined = IfcGridTypeEnum.USERDEFINED + + +notdefined = IfcGridTypeEnum.NOTDEFINED + + +IfcHeatExchangerTypeEnum = enum_namespace() + + +plate = IfcHeatExchangerTypeEnum.PLATE + + +shellandtube = IfcHeatExchangerTypeEnum.SHELLANDTUBE + + +turnoutheating = IfcHeatExchangerTypeEnum.TURNOUTHEATING + + +userdefined = IfcHeatExchangerTypeEnum.USERDEFINED + + +notdefined = IfcHeatExchangerTypeEnum.NOTDEFINED + + +IfcHumidifierTypeEnum = enum_namespace() + + +steaminjection = IfcHumidifierTypeEnum.STEAMINJECTION + + +adiabaticairwasher = IfcHumidifierTypeEnum.ADIABATICAIRWASHER + + +adiabaticpan = IfcHumidifierTypeEnum.ADIABATICPAN + + +adiabaticwettedelement = IfcHumidifierTypeEnum.ADIABATICWETTEDELEMENT + + +adiabaticatomizing = IfcHumidifierTypeEnum.ADIABATICATOMIZING + + +adiabaticultrasonic = IfcHumidifierTypeEnum.ADIABATICULTRASONIC + + +adiabaticrigidmedia = IfcHumidifierTypeEnum.ADIABATICRIGIDMEDIA + + +adiabaticcompressedairnozzle = IfcHumidifierTypeEnum.ADIABATICCOMPRESSEDAIRNOZZLE + + +assistedelectric = IfcHumidifierTypeEnum.ASSISTEDELECTRIC + + +assistednaturalgas = IfcHumidifierTypeEnum.ASSISTEDNATURALGAS + + +assistedpropane = IfcHumidifierTypeEnum.ASSISTEDPROPANE + + +assistedbutane = IfcHumidifierTypeEnum.ASSISTEDBUTANE + + +assistedsteam = IfcHumidifierTypeEnum.ASSISTEDSTEAM + + +userdefined = IfcHumidifierTypeEnum.USERDEFINED + + +notdefined = IfcHumidifierTypeEnum.NOTDEFINED + + +IfcImpactProtectionDeviceTypeEnum = enum_namespace() + + +crashcushion = IfcImpactProtectionDeviceTypeEnum.CRASHCUSHION + + +dampingsystem = IfcImpactProtectionDeviceTypeEnum.DAMPINGSYSTEM + + +fender = IfcImpactProtectionDeviceTypeEnum.FENDER + + +bumper = IfcImpactProtectionDeviceTypeEnum.BUMPER + + +userdefined = IfcImpactProtectionDeviceTypeEnum.USERDEFINED + + +notdefined = IfcImpactProtectionDeviceTypeEnum.NOTDEFINED + + +IfcInterceptorTypeEnum = enum_namespace() + + +cyclonic = IfcInterceptorTypeEnum.CYCLONIC + + +grease = IfcInterceptorTypeEnum.GREASE + + +oil = IfcInterceptorTypeEnum.OIL + + +petrol = IfcInterceptorTypeEnum.PETROL + + +userdefined = IfcInterceptorTypeEnum.USERDEFINED + + +notdefined = IfcInterceptorTypeEnum.NOTDEFINED + + +IfcInternalOrExternalEnum = enum_namespace() + + +internal = IfcInternalOrExternalEnum.INTERNAL + + +external = IfcInternalOrExternalEnum.EXTERNAL + + +external_earth = IfcInternalOrExternalEnum.EXTERNAL_EARTH + + +external_water = IfcInternalOrExternalEnum.EXTERNAL_WATER + + +external_fire = IfcInternalOrExternalEnum.EXTERNAL_FIRE + + +notdefined = IfcInternalOrExternalEnum.NOTDEFINED + + +IfcInventoryTypeEnum = enum_namespace() + + +assetinventory = IfcInventoryTypeEnum.ASSETINVENTORY + + +spaceinventory = IfcInventoryTypeEnum.SPACEINVENTORY + + +furnitureinventory = IfcInventoryTypeEnum.FURNITUREINVENTORY + + +userdefined = IfcInventoryTypeEnum.USERDEFINED + + +notdefined = IfcInventoryTypeEnum.NOTDEFINED + + +IfcJunctionBoxTypeEnum = enum_namespace() + + +data = IfcJunctionBoxTypeEnum.DATA + + +power = IfcJunctionBoxTypeEnum.POWER + + +userdefined = IfcJunctionBoxTypeEnum.USERDEFINED + + +notdefined = IfcJunctionBoxTypeEnum.NOTDEFINED + + +IfcKnotType = enum_namespace() + + +uniform_knots = IfcKnotType.UNIFORM_KNOTS + + +quasi_uniform_knots = IfcKnotType.QUASI_UNIFORM_KNOTS + + +piecewise_bezier_knots = IfcKnotType.PIECEWISE_BEZIER_KNOTS + + +unspecified = IfcKnotType.UNSPECIFIED + + +IfcLaborResourceTypeEnum = enum_namespace() + + +administration = IfcLaborResourceTypeEnum.ADMINISTRATION + + +carpentry = IfcLaborResourceTypeEnum.CARPENTRY + + +cleaning = IfcLaborResourceTypeEnum.CLEANING + + +concrete = IfcLaborResourceTypeEnum.CONCRETE + + +drywall = IfcLaborResourceTypeEnum.DRYWALL + + +electric = IfcLaborResourceTypeEnum.ELECTRIC + + +finishing = IfcLaborResourceTypeEnum.FINISHING + + +flooring = IfcLaborResourceTypeEnum.FLOORING + + +general = IfcLaborResourceTypeEnum.GENERAL + + +hvac = IfcLaborResourceTypeEnum.HVAC + + +landscaping = IfcLaborResourceTypeEnum.LANDSCAPING + + +masonry = IfcLaborResourceTypeEnum.MASONRY + + +painting = IfcLaborResourceTypeEnum.PAINTING + + +paving = IfcLaborResourceTypeEnum.PAVING + + +plumbing = IfcLaborResourceTypeEnum.PLUMBING + + +roofing = IfcLaborResourceTypeEnum.ROOFING + + +sitegrading = IfcLaborResourceTypeEnum.SITEGRADING + + +steelwork = IfcLaborResourceTypeEnum.STEELWORK + + +surveying = IfcLaborResourceTypeEnum.SURVEYING + + +userdefined = IfcLaborResourceTypeEnum.USERDEFINED + + +notdefined = IfcLaborResourceTypeEnum.NOTDEFINED + + +IfcLampTypeEnum = enum_namespace() + + +compactfluorescent = IfcLampTypeEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLampTypeEnum.FLUORESCENT + + +halogen = IfcLampTypeEnum.HALOGEN + + +highpressuremercury = IfcLampTypeEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLampTypeEnum.HIGHPRESSURESODIUM + + +led = IfcLampTypeEnum.LED + + +metalhalide = IfcLampTypeEnum.METALHALIDE + + +oled = IfcLampTypeEnum.OLED + + +tungstenfilament = IfcLampTypeEnum.TUNGSTENFILAMENT + + +userdefined = IfcLampTypeEnum.USERDEFINED + + +notdefined = IfcLampTypeEnum.NOTDEFINED + + +IfcLayerSetDirectionEnum = enum_namespace() + + +axis1 = IfcLayerSetDirectionEnum.AXIS1 + + +axis2 = IfcLayerSetDirectionEnum.AXIS2 + + +axis3 = IfcLayerSetDirectionEnum.AXIS3 + + +IfcLightDistributionCurveEnum = enum_namespace() + + +type_a = IfcLightDistributionCurveEnum.TYPE_A + + +type_b = IfcLightDistributionCurveEnum.TYPE_B + + +type_c = IfcLightDistributionCurveEnum.TYPE_C + + +notdefined = IfcLightDistributionCurveEnum.NOTDEFINED + + +IfcLightEmissionSourceEnum = enum_namespace() + + +compactfluorescent = IfcLightEmissionSourceEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLightEmissionSourceEnum.FLUORESCENT + + +highpressuremercury = IfcLightEmissionSourceEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLightEmissionSourceEnum.HIGHPRESSURESODIUM + + +lightemittingdiode = IfcLightEmissionSourceEnum.LIGHTEMITTINGDIODE + + +lowpressuresodium = IfcLightEmissionSourceEnum.LOWPRESSURESODIUM + + +lowvoltagehalogen = IfcLightEmissionSourceEnum.LOWVOLTAGEHALOGEN + + +mainvoltagehalogen = IfcLightEmissionSourceEnum.MAINVOLTAGEHALOGEN + + +metalhalide = IfcLightEmissionSourceEnum.METALHALIDE + + +tungstenfilament = IfcLightEmissionSourceEnum.TUNGSTENFILAMENT + + +notdefined = IfcLightEmissionSourceEnum.NOTDEFINED + + +IfcLightFixtureTypeEnum = enum_namespace() + + +pointsource = IfcLightFixtureTypeEnum.POINTSOURCE + + +directionsource = IfcLightFixtureTypeEnum.DIRECTIONSOURCE + + +securitylighting = IfcLightFixtureTypeEnum.SECURITYLIGHTING + + +userdefined = IfcLightFixtureTypeEnum.USERDEFINED + + +notdefined = IfcLightFixtureTypeEnum.NOTDEFINED + + +IfcLiquidTerminalTypeEnum = enum_namespace() + + +loadingarm = IfcLiquidTerminalTypeEnum.LOADINGARM + + +hosereel = IfcLiquidTerminalTypeEnum.HOSEREEL + + +userdefined = IfcLiquidTerminalTypeEnum.USERDEFINED + + +notdefined = IfcLiquidTerminalTypeEnum.NOTDEFINED + + +IfcLoadGroupTypeEnum = enum_namespace() + + +load_group = IfcLoadGroupTypeEnum.LOAD_GROUP + + +load_case = IfcLoadGroupTypeEnum.LOAD_CASE + + +load_combination = IfcLoadGroupTypeEnum.LOAD_COMBINATION + + +userdefined = IfcLoadGroupTypeEnum.USERDEFINED + + +notdefined = IfcLoadGroupTypeEnum.NOTDEFINED + + +IfcLogicalOperatorEnum = enum_namespace() + + +logicaland = IfcLogicalOperatorEnum.LOGICALAND + + +logicalor = IfcLogicalOperatorEnum.LOGICALOR + + +logicalxor = IfcLogicalOperatorEnum.LOGICALXOR + + +logicalnotand = IfcLogicalOperatorEnum.LOGICALNOTAND + + +logicalnotor = IfcLogicalOperatorEnum.LOGICALNOTOR + + +IfcMarineFacilityTypeEnum = enum_namespace() + + +canal = IfcMarineFacilityTypeEnum.CANAL + + +waterwayshiplift = IfcMarineFacilityTypeEnum.WATERWAYSHIPLIFT + + +revetment = IfcMarineFacilityTypeEnum.REVETMENT + + +launchrecovery = IfcMarineFacilityTypeEnum.LAUNCHRECOVERY + + +marinedefence = IfcMarineFacilityTypeEnum.MARINEDEFENCE + + +hydrolift = IfcMarineFacilityTypeEnum.HYDROLIFT + + +shipyard = IfcMarineFacilityTypeEnum.SHIPYARD + + +shiplift = IfcMarineFacilityTypeEnum.SHIPLIFT + + +port = IfcMarineFacilityTypeEnum.PORT + + +quay = IfcMarineFacilityTypeEnum.QUAY + + +floatingdock = IfcMarineFacilityTypeEnum.FLOATINGDOCK + + +navigationalchannel = IfcMarineFacilityTypeEnum.NAVIGATIONALCHANNEL + + +breakwater = IfcMarineFacilityTypeEnum.BREAKWATER + + +drydock = IfcMarineFacilityTypeEnum.DRYDOCK + + +jetty = IfcMarineFacilityTypeEnum.JETTY + + +shiplock = IfcMarineFacilityTypeEnum.SHIPLOCK + + +barrierbeach = IfcMarineFacilityTypeEnum.BARRIERBEACH + + +slipway = IfcMarineFacilityTypeEnum.SLIPWAY + + +waterway = IfcMarineFacilityTypeEnum.WATERWAY + + +userdefined = IfcMarineFacilityTypeEnum.USERDEFINED + + +notdefined = IfcMarineFacilityTypeEnum.NOTDEFINED + + +IfcMarinePartTypeEnum = enum_namespace() + + +crest = IfcMarinePartTypeEnum.CREST + + +manufacturing = IfcMarinePartTypeEnum.MANUFACTURING + + +lowwaterline = IfcMarinePartTypeEnum.LOWWATERLINE + + +core = IfcMarinePartTypeEnum.CORE + + +waterfield = IfcMarinePartTypeEnum.WATERFIELD + + +cill_level = IfcMarinePartTypeEnum.CILL_LEVEL + + +berthingstructure = IfcMarinePartTypeEnum.BERTHINGSTRUCTURE + + +copelevel = IfcMarinePartTypeEnum.COPELEVEL + + +chamber = IfcMarinePartTypeEnum.CHAMBER + + +storage = IfcMarinePartTypeEnum.STORAGE + + +approachchannel = IfcMarinePartTypeEnum.APPROACHCHANNEL + + +vehicleservicing = IfcMarinePartTypeEnum.VEHICLESERVICING + + +shiptransfer = IfcMarinePartTypeEnum.SHIPTRANSFER + + +gatehead = IfcMarinePartTypeEnum.GATEHEAD + + +gudingstructure = IfcMarinePartTypeEnum.GUDINGSTRUCTURE + + +belowwaterline = IfcMarinePartTypeEnum.BELOWWATERLINE + + +weatherside = IfcMarinePartTypeEnum.WEATHERSIDE + + +landfield = IfcMarinePartTypeEnum.LANDFIELD + + +protection = IfcMarinePartTypeEnum.PROTECTION + + +leewardside = IfcMarinePartTypeEnum.LEEWARDSIDE + + +abovewaterline = IfcMarinePartTypeEnum.ABOVEWATERLINE + + +anchorage = IfcMarinePartTypeEnum.ANCHORAGE + + +navigationalarea = IfcMarinePartTypeEnum.NAVIGATIONALAREA + + +highwaterline = IfcMarinePartTypeEnum.HIGHWATERLINE + + +userdefined = IfcMarinePartTypeEnum.USERDEFINED + + +notdefined = IfcMarinePartTypeEnum.NOTDEFINED + + +IfcMechanicalFastenerTypeEnum = enum_namespace() + + +anchorbolt = IfcMechanicalFastenerTypeEnum.ANCHORBOLT + + +bolt = IfcMechanicalFastenerTypeEnum.BOLT + + +dowel = IfcMechanicalFastenerTypeEnum.DOWEL + + +nail = IfcMechanicalFastenerTypeEnum.NAIL + + +nailplate = IfcMechanicalFastenerTypeEnum.NAILPLATE + + +rivet = IfcMechanicalFastenerTypeEnum.RIVET + + +screw = IfcMechanicalFastenerTypeEnum.SCREW + + +shearconnector = IfcMechanicalFastenerTypeEnum.SHEARCONNECTOR + + +staple = IfcMechanicalFastenerTypeEnum.STAPLE + + +studshearconnector = IfcMechanicalFastenerTypeEnum.STUDSHEARCONNECTOR + + +coupler = IfcMechanicalFastenerTypeEnum.COUPLER + + +railjoint = IfcMechanicalFastenerTypeEnum.RAILJOINT + + +railfastening = IfcMechanicalFastenerTypeEnum.RAILFASTENING + + +chain = IfcMechanicalFastenerTypeEnum.CHAIN + + +rope = IfcMechanicalFastenerTypeEnum.ROPE + + +userdefined = IfcMechanicalFastenerTypeEnum.USERDEFINED + + +notdefined = IfcMechanicalFastenerTypeEnum.NOTDEFINED + + +IfcMedicalDeviceTypeEnum = enum_namespace() + + +airstation = IfcMedicalDeviceTypeEnum.AIRSTATION + + +feedairunit = IfcMedicalDeviceTypeEnum.FEEDAIRUNIT + + +oxygengenerator = IfcMedicalDeviceTypeEnum.OXYGENGENERATOR + + +oxygenplant = IfcMedicalDeviceTypeEnum.OXYGENPLANT + + +vacuumstation = IfcMedicalDeviceTypeEnum.VACUUMSTATION + + +userdefined = IfcMedicalDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMedicalDeviceTypeEnum.NOTDEFINED + + +IfcMemberTypeEnum = enum_namespace() + + +brace = IfcMemberTypeEnum.BRACE + + +chord = IfcMemberTypeEnum.CHORD + + +collar = IfcMemberTypeEnum.COLLAR + + +member = IfcMemberTypeEnum.MEMBER + + +mullion = IfcMemberTypeEnum.MULLION + + +plate = IfcMemberTypeEnum.PLATE + + +post = IfcMemberTypeEnum.POST + + +purlin = IfcMemberTypeEnum.PURLIN + + +rafter = IfcMemberTypeEnum.RAFTER + + +stringer = IfcMemberTypeEnum.STRINGER + + +strut = IfcMemberTypeEnum.STRUT + + +stud = IfcMemberTypeEnum.STUD + + +stiffening_rib = IfcMemberTypeEnum.STIFFENING_RIB + + +arch_segment = IfcMemberTypeEnum.ARCH_SEGMENT + + +suspension_cable = IfcMemberTypeEnum.SUSPENSION_CABLE + + +suspender = IfcMemberTypeEnum.SUSPENDER + + +stay_cable = IfcMemberTypeEnum.STAY_CABLE + + +structuralcable = IfcMemberTypeEnum.STRUCTURALCABLE + + +tiebar = IfcMemberTypeEnum.TIEBAR + + +userdefined = IfcMemberTypeEnum.USERDEFINED + + +notdefined = IfcMemberTypeEnum.NOTDEFINED + + +IfcMobileTelecommunicationsApplianceTypeEnum = enum_namespace() + + +e_utran_node_b = IfcMobileTelecommunicationsApplianceTypeEnum.E_UTRAN_NODE_B + + +remote_radio_unit = IfcMobileTelecommunicationsApplianceTypeEnum.REMOTE_RADIO_UNIT + + +accesspoint = IfcMobileTelecommunicationsApplianceTypeEnum.ACCESSPOINT + + +basetransceiverstation = IfcMobileTelecommunicationsApplianceTypeEnum.BASETRANSCEIVERSTATION + + +remoteunit = IfcMobileTelecommunicationsApplianceTypeEnum.REMOTEUNIT + + +basebandunit = IfcMobileTelecommunicationsApplianceTypeEnum.BASEBANDUNIT + + +masterunit = IfcMobileTelecommunicationsApplianceTypeEnum.MASTERUNIT + + +userdefined = IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcMobileTelecommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcMooringDeviceTypeEnum = enum_namespace() + + +linetensioner = IfcMooringDeviceTypeEnum.LINETENSIONER + + +magneticdevice = IfcMooringDeviceTypeEnum.MAGNETICDEVICE + + +mooringhooks = IfcMooringDeviceTypeEnum.MOORINGHOOKS + + +vacuumdevice = IfcMooringDeviceTypeEnum.VACUUMDEVICE + + +bollard = IfcMooringDeviceTypeEnum.BOLLARD + + +userdefined = IfcMooringDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMooringDeviceTypeEnum.NOTDEFINED + + +IfcMotorConnectionTypeEnum = enum_namespace() + + +beltdrive = IfcMotorConnectionTypeEnum.BELTDRIVE + + +coupling = IfcMotorConnectionTypeEnum.COUPLING + + +directdrive = IfcMotorConnectionTypeEnum.DIRECTDRIVE + + +userdefined = IfcMotorConnectionTypeEnum.USERDEFINED + + +notdefined = IfcMotorConnectionTypeEnum.NOTDEFINED + + +IfcNavigationElementTypeEnum = enum_namespace() + + +beacon = IfcNavigationElementTypeEnum.BEACON + + +buoy = IfcNavigationElementTypeEnum.BUOY + + +userdefined = IfcNavigationElementTypeEnum.USERDEFINED + + +notdefined = IfcNavigationElementTypeEnum.NOTDEFINED + + +IfcObjectTypeEnum = enum_namespace() + + +product = IfcObjectTypeEnum.PRODUCT + + +process = IfcObjectTypeEnum.PROCESS + + +control = IfcObjectTypeEnum.CONTROL + + +resource = IfcObjectTypeEnum.RESOURCE + + +actor = IfcObjectTypeEnum.ACTOR + + +group = IfcObjectTypeEnum.GROUP + + +project = IfcObjectTypeEnum.PROJECT + + +notdefined = IfcObjectTypeEnum.NOTDEFINED + + +IfcObjectiveEnum = enum_namespace() + + +codecompliance = IfcObjectiveEnum.CODECOMPLIANCE + + +codewaiver = IfcObjectiveEnum.CODEWAIVER + + +designintent = IfcObjectiveEnum.DESIGNINTENT + + +external = IfcObjectiveEnum.EXTERNAL + + +healthandsafety = IfcObjectiveEnum.HEALTHANDSAFETY + + +mergeconflict = IfcObjectiveEnum.MERGECONFLICT + + +modelview = IfcObjectiveEnum.MODELVIEW + + +parameter = IfcObjectiveEnum.PARAMETER + + +requirement = IfcObjectiveEnum.REQUIREMENT + + +specification = IfcObjectiveEnum.SPECIFICATION + + +triggercondition = IfcObjectiveEnum.TRIGGERCONDITION + + +userdefined = IfcObjectiveEnum.USERDEFINED + + +notdefined = IfcObjectiveEnum.NOTDEFINED + + +IfcOccupantTypeEnum = enum_namespace() + + +assignee = IfcOccupantTypeEnum.ASSIGNEE + + +assignor = IfcOccupantTypeEnum.ASSIGNOR + + +lessee = IfcOccupantTypeEnum.LESSEE + + +lessor = IfcOccupantTypeEnum.LESSOR + + +lettingagent = IfcOccupantTypeEnum.LETTINGAGENT + + +owner = IfcOccupantTypeEnum.OWNER + + +tenant = IfcOccupantTypeEnum.TENANT + + +userdefined = IfcOccupantTypeEnum.USERDEFINED + + +notdefined = IfcOccupantTypeEnum.NOTDEFINED + + +IfcOpeningElementTypeEnum = enum_namespace() + + +opening = IfcOpeningElementTypeEnum.OPENING + + +recess = IfcOpeningElementTypeEnum.RECESS + + +userdefined = IfcOpeningElementTypeEnum.USERDEFINED + + +notdefined = IfcOpeningElementTypeEnum.NOTDEFINED + + +IfcOutletTypeEnum = enum_namespace() + + +audiovisualoutlet = IfcOutletTypeEnum.AUDIOVISUALOUTLET + + +communicationsoutlet = IfcOutletTypeEnum.COMMUNICATIONSOUTLET + + +poweroutlet = IfcOutletTypeEnum.POWEROUTLET + + +dataoutlet = IfcOutletTypeEnum.DATAOUTLET + + +telephoneoutlet = IfcOutletTypeEnum.TELEPHONEOUTLET + + +userdefined = IfcOutletTypeEnum.USERDEFINED + + +notdefined = IfcOutletTypeEnum.NOTDEFINED + + +IfcPavementTypeEnum = enum_namespace() + + +flexible = IfcPavementTypeEnum.FLEXIBLE + + +rigid = IfcPavementTypeEnum.RIGID + + +userdefined = IfcPavementTypeEnum.USERDEFINED + + +notdefined = IfcPavementTypeEnum.NOTDEFINED + + +IfcPerformanceHistoryTypeEnum = enum_namespace() + + +userdefined = IfcPerformanceHistoryTypeEnum.USERDEFINED + + +notdefined = IfcPerformanceHistoryTypeEnum.NOTDEFINED + + +IfcPermeableCoveringOperationEnum = enum_namespace() + + +grill = IfcPermeableCoveringOperationEnum.GRILL + + +louver = IfcPermeableCoveringOperationEnum.LOUVER + + +screen = IfcPermeableCoveringOperationEnum.SCREEN + + +userdefined = IfcPermeableCoveringOperationEnum.USERDEFINED + + +notdefined = IfcPermeableCoveringOperationEnum.NOTDEFINED + + +IfcPermitTypeEnum = enum_namespace() + + +access = IfcPermitTypeEnum.ACCESS + + +building = IfcPermitTypeEnum.BUILDING + + +work = IfcPermitTypeEnum.WORK + + +userdefined = IfcPermitTypeEnum.USERDEFINED + + +notdefined = IfcPermitTypeEnum.NOTDEFINED + + +IfcPhysicalOrVirtualEnum = enum_namespace() + + +physical = IfcPhysicalOrVirtualEnum.PHYSICAL + + +virtual = IfcPhysicalOrVirtualEnum.VIRTUAL + + +notdefined = IfcPhysicalOrVirtualEnum.NOTDEFINED + + +IfcPileConstructionEnum = enum_namespace() + + +cast_in_place = IfcPileConstructionEnum.CAST_IN_PLACE + + +composite = IfcPileConstructionEnum.COMPOSITE + + +precast_concrete = IfcPileConstructionEnum.PRECAST_CONCRETE + + +prefab_steel = IfcPileConstructionEnum.PREFAB_STEEL + + +userdefined = IfcPileConstructionEnum.USERDEFINED + + +notdefined = IfcPileConstructionEnum.NOTDEFINED + + +IfcPileTypeEnum = enum_namespace() + + +bored = IfcPileTypeEnum.BORED + + +driven = IfcPileTypeEnum.DRIVEN + + +jetgrouting = IfcPileTypeEnum.JETGROUTING + + +cohesion = IfcPileTypeEnum.COHESION + + +friction = IfcPileTypeEnum.FRICTION + + +support = IfcPileTypeEnum.SUPPORT + + +userdefined = IfcPileTypeEnum.USERDEFINED + + +notdefined = IfcPileTypeEnum.NOTDEFINED + + +IfcPipeFittingTypeEnum = enum_namespace() + + +bend = IfcPipeFittingTypeEnum.BEND + + +connector = IfcPipeFittingTypeEnum.CONNECTOR + + +entry = IfcPipeFittingTypeEnum.ENTRY + + +exit = IfcPipeFittingTypeEnum.EXIT + + +junction = IfcPipeFittingTypeEnum.JUNCTION + + +obstruction = IfcPipeFittingTypeEnum.OBSTRUCTION + + +transition = IfcPipeFittingTypeEnum.TRANSITION + + +userdefined = IfcPipeFittingTypeEnum.USERDEFINED + + +notdefined = IfcPipeFittingTypeEnum.NOTDEFINED + + +IfcPipeSegmentTypeEnum = enum_namespace() + + +culvert = IfcPipeSegmentTypeEnum.CULVERT + + +flexiblesegment = IfcPipeSegmentTypeEnum.FLEXIBLESEGMENT + + +rigidsegment = IfcPipeSegmentTypeEnum.RIGIDSEGMENT + + +gutter = IfcPipeSegmentTypeEnum.GUTTER + + +spool = IfcPipeSegmentTypeEnum.SPOOL + + +userdefined = IfcPipeSegmentTypeEnum.USERDEFINED + + +notdefined = IfcPipeSegmentTypeEnum.NOTDEFINED + + +IfcPlateTypeEnum = enum_namespace() + + +curtain_panel = IfcPlateTypeEnum.CURTAIN_PANEL + + +sheet = IfcPlateTypeEnum.SHEET + + +flange_plate = IfcPlateTypeEnum.FLANGE_PLATE + + +web_plate = IfcPlateTypeEnum.WEB_PLATE + + +stiffener_plate = IfcPlateTypeEnum.STIFFENER_PLATE + + +gusset_plate = IfcPlateTypeEnum.GUSSET_PLATE + + +cover_plate = IfcPlateTypeEnum.COVER_PLATE + + +splice_plate = IfcPlateTypeEnum.SPLICE_PLATE + + +base_plate = IfcPlateTypeEnum.BASE_PLATE + + +userdefined = IfcPlateTypeEnum.USERDEFINED + + +notdefined = IfcPlateTypeEnum.NOTDEFINED + + +IfcPreferredSurfaceCurveRepresentation = enum_namespace() + + +curve3d = IfcPreferredSurfaceCurveRepresentation.CURVE3D + + +pcurve_s1 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S1 + + +pcurve_s2 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S2 + + +IfcProcedureTypeEnum = enum_namespace() + + +advice_caution = IfcProcedureTypeEnum.ADVICE_CAUTION + + +advice_note = IfcProcedureTypeEnum.ADVICE_NOTE + + +advice_warning = IfcProcedureTypeEnum.ADVICE_WARNING + + +calibration = IfcProcedureTypeEnum.CALIBRATION + + +diagnostic = IfcProcedureTypeEnum.DIAGNOSTIC + + +shutdown = IfcProcedureTypeEnum.SHUTDOWN + + +startup = IfcProcedureTypeEnum.STARTUP + + +userdefined = IfcProcedureTypeEnum.USERDEFINED + + +notdefined = IfcProcedureTypeEnum.NOTDEFINED + + +IfcProfileTypeEnum = enum_namespace() + + +curve = IfcProfileTypeEnum.CURVE + + +area = IfcProfileTypeEnum.AREA + + +IfcProjectOrderTypeEnum = enum_namespace() + + +changeorder = IfcProjectOrderTypeEnum.CHANGEORDER + + +maintenanceworkorder = IfcProjectOrderTypeEnum.MAINTENANCEWORKORDER + + +moveorder = IfcProjectOrderTypeEnum.MOVEORDER + + +purchaseorder = IfcProjectOrderTypeEnum.PURCHASEORDER + + +workorder = IfcProjectOrderTypeEnum.WORKORDER + + +userdefined = IfcProjectOrderTypeEnum.USERDEFINED + + +notdefined = IfcProjectOrderTypeEnum.NOTDEFINED + + +IfcProjectedOrTrueLengthEnum = enum_namespace() + + +projected_length = IfcProjectedOrTrueLengthEnum.PROJECTED_LENGTH + + +true_length = IfcProjectedOrTrueLengthEnum.TRUE_LENGTH + + +IfcProjectionElementTypeEnum = enum_namespace() + + +blister = IfcProjectionElementTypeEnum.BLISTER + + +deviator = IfcProjectionElementTypeEnum.DEVIATOR + + +userdefined = IfcProjectionElementTypeEnum.USERDEFINED + + +notdefined = IfcProjectionElementTypeEnum.NOTDEFINED + + +IfcPropertySetTemplateTypeEnum = enum_namespace() + + +pset_typedrivenonly = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENONLY + + +pset_typedrivenoverride = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENOVERRIDE + + +pset_occurrencedriven = IfcPropertySetTemplateTypeEnum.PSET_OCCURRENCEDRIVEN + + +pset_performancedriven = IfcPropertySetTemplateTypeEnum.PSET_PERFORMANCEDRIVEN + + +qto_typedrivenonly = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENONLY + + +qto_typedrivenoverride = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENOVERRIDE + + +qto_occurrencedriven = IfcPropertySetTemplateTypeEnum.QTO_OCCURRENCEDRIVEN + + +notdefined = IfcPropertySetTemplateTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTrippingUnitTypeEnum = enum_namespace() + + +electronic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTRONIC + + +electromagnetic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTROMAGNETIC + + +residualcurrent = IfcProtectiveDeviceTrippingUnitTypeEnum.RESIDUALCURRENT + + +thermal = IfcProtectiveDeviceTrippingUnitTypeEnum.THERMAL + + +userdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTypeEnum = enum_namespace() + + +circuitbreaker = IfcProtectiveDeviceTypeEnum.CIRCUITBREAKER + + +earthleakagecircuitbreaker = IfcProtectiveDeviceTypeEnum.EARTHLEAKAGECIRCUITBREAKER + + +earthingswitch = IfcProtectiveDeviceTypeEnum.EARTHINGSWITCH + + +fusedisconnector = IfcProtectiveDeviceTypeEnum.FUSEDISCONNECTOR + + +residualcurrentcircuitbreaker = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTCIRCUITBREAKER + + +residualcurrentswitch = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTSWITCH + + +varistor = IfcProtectiveDeviceTypeEnum.VARISTOR + + +anti_arcing_device = IfcProtectiveDeviceTypeEnum.ANTI_ARCING_DEVICE + + +sparkgap = IfcProtectiveDeviceTypeEnum.SPARKGAP + + +voltagelimiter = IfcProtectiveDeviceTypeEnum.VOLTAGELIMITER + + +userdefined = IfcProtectiveDeviceTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTypeEnum.NOTDEFINED + + +IfcPumpTypeEnum = enum_namespace() + + +circulator = IfcPumpTypeEnum.CIRCULATOR + + +endsuction = IfcPumpTypeEnum.ENDSUCTION + + +splitcase = IfcPumpTypeEnum.SPLITCASE + + +submersiblepump = IfcPumpTypeEnum.SUBMERSIBLEPUMP + + +sumppump = IfcPumpTypeEnum.SUMPPUMP + + +verticalinline = IfcPumpTypeEnum.VERTICALINLINE + + +verticalturbine = IfcPumpTypeEnum.VERTICALTURBINE + + +userdefined = IfcPumpTypeEnum.USERDEFINED + + +notdefined = IfcPumpTypeEnum.NOTDEFINED + + +IfcRailTypeEnum = enum_namespace() + + +rackrail = IfcRailTypeEnum.RACKRAIL + + +blade = IfcRailTypeEnum.BLADE + + +guardrail = IfcRailTypeEnum.GUARDRAIL + + +stockrail = IfcRailTypeEnum.STOCKRAIL + + +checkrail = IfcRailTypeEnum.CHECKRAIL + + +rail = IfcRailTypeEnum.RAIL + + +userdefined = IfcRailTypeEnum.USERDEFINED + + +notdefined = IfcRailTypeEnum.NOTDEFINED + + +IfcRailingTypeEnum = enum_namespace() + + +handrail = IfcRailingTypeEnum.HANDRAIL + + +guardrail = IfcRailingTypeEnum.GUARDRAIL + + +balustrade = IfcRailingTypeEnum.BALUSTRADE + + +fence = IfcRailingTypeEnum.FENCE + + +userdefined = IfcRailingTypeEnum.USERDEFINED + + +notdefined = IfcRailingTypeEnum.NOTDEFINED + + +IfcRailwayPartTypeEnum = enum_namespace() + + +trackstructure = IfcRailwayPartTypeEnum.TRACKSTRUCTURE + + +trackstructurepart = IfcRailwayPartTypeEnum.TRACKSTRUCTUREPART + + +linesidestructurepart = IfcRailwayPartTypeEnum.LINESIDESTRUCTUREPART + + +dilatationsuperstructure = IfcRailwayPartTypeEnum.DILATATIONSUPERSTRUCTURE + + +plaintracksupestructure = IfcRailwayPartTypeEnum.PLAINTRACKSUPESTRUCTURE + + +linesidestructure = IfcRailwayPartTypeEnum.LINESIDESTRUCTURE + + +superstructure = IfcRailwayPartTypeEnum.SUPERSTRUCTURE + + +turnoutsuperstructure = IfcRailwayPartTypeEnum.TURNOUTSUPERSTRUCTURE + + +userdefined = IfcRailwayPartTypeEnum.USERDEFINED + + +notdefined = IfcRailwayPartTypeEnum.NOTDEFINED + + +IfcRailwayTypeEnum = enum_namespace() + + +userdefined = IfcRailwayTypeEnum.USERDEFINED + + +notdefined = IfcRailwayTypeEnum.NOTDEFINED + + +IfcRampFlightTypeEnum = enum_namespace() + + +straight = IfcRampFlightTypeEnum.STRAIGHT + + +spiral = IfcRampFlightTypeEnum.SPIRAL + + +userdefined = IfcRampFlightTypeEnum.USERDEFINED + + +notdefined = IfcRampFlightTypeEnum.NOTDEFINED + + +IfcRampTypeEnum = enum_namespace() + + +straight_run_ramp = IfcRampTypeEnum.STRAIGHT_RUN_RAMP + + +two_straight_run_ramp = IfcRampTypeEnum.TWO_STRAIGHT_RUN_RAMP + + +quarter_turn_ramp = IfcRampTypeEnum.QUARTER_TURN_RAMP + + +two_quarter_turn_ramp = IfcRampTypeEnum.TWO_QUARTER_TURN_RAMP + + +half_turn_ramp = IfcRampTypeEnum.HALF_TURN_RAMP + + +spiral_ramp = IfcRampTypeEnum.SPIRAL_RAMP + + +userdefined = IfcRampTypeEnum.USERDEFINED + + +notdefined = IfcRampTypeEnum.NOTDEFINED + + +IfcRecurrenceTypeEnum = enum_namespace() + + +daily = IfcRecurrenceTypeEnum.DAILY + + +weekly = IfcRecurrenceTypeEnum.WEEKLY + + +monthly_by_day_of_month = IfcRecurrenceTypeEnum.MONTHLY_BY_DAY_OF_MONTH + + +monthly_by_position = IfcRecurrenceTypeEnum.MONTHLY_BY_POSITION + + +by_day_count = IfcRecurrenceTypeEnum.BY_DAY_COUNT + + +by_weekday_count = IfcRecurrenceTypeEnum.BY_WEEKDAY_COUNT + + +yearly_by_day_of_month = IfcRecurrenceTypeEnum.YEARLY_BY_DAY_OF_MONTH + + +yearly_by_position = IfcRecurrenceTypeEnum.YEARLY_BY_POSITION + + +IfcReferentTypeEnum = enum_namespace() + + +kilopoint = IfcReferentTypeEnum.KILOPOINT + + +milepoint = IfcReferentTypeEnum.MILEPOINT + + +station = IfcReferentTypeEnum.STATION + + +referencemarker = IfcReferentTypeEnum.REFERENCEMARKER + + +userdefined = IfcReferentTypeEnum.USERDEFINED + + +notdefined = IfcReferentTypeEnum.NOTDEFINED + + +IfcReflectanceMethodEnum = enum_namespace() + + +blinn = IfcReflectanceMethodEnum.BLINN + + +flat = IfcReflectanceMethodEnum.FLAT + + +glass = IfcReflectanceMethodEnum.GLASS + + +matt = IfcReflectanceMethodEnum.MATT + + +metal = IfcReflectanceMethodEnum.METAL + + +mirror = IfcReflectanceMethodEnum.MIRROR + + +phong = IfcReflectanceMethodEnum.PHONG + + +plastic = IfcReflectanceMethodEnum.PLASTIC + + +strauss = IfcReflectanceMethodEnum.STRAUSS + + +notdefined = IfcReflectanceMethodEnum.NOTDEFINED + + +IfcReinforcedSoilTypeEnum = enum_namespace() + + +surchargepreloaded = IfcReinforcedSoilTypeEnum.SURCHARGEPRELOADED + + +verticallydrained = IfcReinforcedSoilTypeEnum.VERTICALLYDRAINED + + +dynamicallycompacted = IfcReinforcedSoilTypeEnum.DYNAMICALLYCOMPACTED + + +replaced = IfcReinforcedSoilTypeEnum.REPLACED + + +rollercompacted = IfcReinforcedSoilTypeEnum.ROLLERCOMPACTED + + +grouted = IfcReinforcedSoilTypeEnum.GROUTED + + +userdefined = IfcReinforcedSoilTypeEnum.USERDEFINED + + +notdefined = IfcReinforcedSoilTypeEnum.NOTDEFINED + + +IfcReinforcingBarRoleEnum = enum_namespace() + + +main = IfcReinforcingBarRoleEnum.MAIN + + +shear = IfcReinforcingBarRoleEnum.SHEAR + + +ligature = IfcReinforcingBarRoleEnum.LIGATURE + + +stud = IfcReinforcingBarRoleEnum.STUD + + +punching = IfcReinforcingBarRoleEnum.PUNCHING + + +edge = IfcReinforcingBarRoleEnum.EDGE + + +ring = IfcReinforcingBarRoleEnum.RING + + +anchoring = IfcReinforcingBarRoleEnum.ANCHORING + + +userdefined = IfcReinforcingBarRoleEnum.USERDEFINED + + +notdefined = IfcReinforcingBarRoleEnum.NOTDEFINED + + +IfcReinforcingBarSurfaceEnum = enum_namespace() + + +plain = IfcReinforcingBarSurfaceEnum.PLAIN + + +textured = IfcReinforcingBarSurfaceEnum.TEXTURED + + +IfcReinforcingBarTypeEnum = enum_namespace() + + +anchoring = IfcReinforcingBarTypeEnum.ANCHORING + + +edge = IfcReinforcingBarTypeEnum.EDGE + + +ligature = IfcReinforcingBarTypeEnum.LIGATURE + + +main = IfcReinforcingBarTypeEnum.MAIN + + +punching = IfcReinforcingBarTypeEnum.PUNCHING + + +ring = IfcReinforcingBarTypeEnum.RING + + +shear = IfcReinforcingBarTypeEnum.SHEAR + + +stud = IfcReinforcingBarTypeEnum.STUD + + +spacebar = IfcReinforcingBarTypeEnum.SPACEBAR + + +userdefined = IfcReinforcingBarTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingBarTypeEnum.NOTDEFINED + + +IfcReinforcingMeshTypeEnum = enum_namespace() + + +userdefined = IfcReinforcingMeshTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingMeshTypeEnum.NOTDEFINED + + +IfcRoadPartTypeEnum = enum_namespace() + + +roadsidepart = IfcRoadPartTypeEnum.ROADSIDEPART + + +bus_stop = IfcRoadPartTypeEnum.BUS_STOP + + +hardshoulder = IfcRoadPartTypeEnum.HARDSHOULDER + + +intersection = IfcRoadPartTypeEnum.INTERSECTION + + +passingbay = IfcRoadPartTypeEnum.PASSINGBAY + + +roadwayplateau = IfcRoadPartTypeEnum.ROADWAYPLATEAU + + +roadside = IfcRoadPartTypeEnum.ROADSIDE + + +refugeisland = IfcRoadPartTypeEnum.REFUGEISLAND + + +tollplaza = IfcRoadPartTypeEnum.TOLLPLAZA + + +centralreserve = IfcRoadPartTypeEnum.CENTRALRESERVE + + +sidewalk = IfcRoadPartTypeEnum.SIDEWALK + + +parkingbay = IfcRoadPartTypeEnum.PARKINGBAY + + +railwaycrossing = IfcRoadPartTypeEnum.RAILWAYCROSSING + + +pedestrian_crossing = IfcRoadPartTypeEnum.PEDESTRIAN_CROSSING + + +softshoulder = IfcRoadPartTypeEnum.SOFTSHOULDER + + +bicyclecrossing = IfcRoadPartTypeEnum.BICYCLECROSSING + + +centralisland = IfcRoadPartTypeEnum.CENTRALISLAND + + +shoulder = IfcRoadPartTypeEnum.SHOULDER + + +trafficlane = IfcRoadPartTypeEnum.TRAFFICLANE + + +roadsegment = IfcRoadPartTypeEnum.ROADSEGMENT + + +roundabout = IfcRoadPartTypeEnum.ROUNDABOUT + + +layby = IfcRoadPartTypeEnum.LAYBY + + +carriageway = IfcRoadPartTypeEnum.CARRIAGEWAY + + +trafficisland = IfcRoadPartTypeEnum.TRAFFICISLAND + + +userdefined = IfcRoadPartTypeEnum.USERDEFINED + + +notdefined = IfcRoadPartTypeEnum.NOTDEFINED + + +IfcRoadTypeEnum = enum_namespace() + + +userdefined = IfcRoadTypeEnum.USERDEFINED + + +notdefined = IfcRoadTypeEnum.NOTDEFINED + + +IfcRoleEnum = enum_namespace() + + +supplier = IfcRoleEnum.SUPPLIER + + +manufacturer = IfcRoleEnum.MANUFACTURER + + +contractor = IfcRoleEnum.CONTRACTOR + + +subcontractor = IfcRoleEnum.SUBCONTRACTOR + + +architect = IfcRoleEnum.ARCHITECT + + +structuralengineer = IfcRoleEnum.STRUCTURALENGINEER + + +costengineer = IfcRoleEnum.COSTENGINEER + + +client = IfcRoleEnum.CLIENT + + +buildingowner = IfcRoleEnum.BUILDINGOWNER + + +buildingoperator = IfcRoleEnum.BUILDINGOPERATOR + + +mechanicalengineer = IfcRoleEnum.MECHANICALENGINEER + + +electricalengineer = IfcRoleEnum.ELECTRICALENGINEER + + +projectmanager = IfcRoleEnum.PROJECTMANAGER + + +facilitiesmanager = IfcRoleEnum.FACILITIESMANAGER + + +civilengineer = IfcRoleEnum.CIVILENGINEER + + +commissioningengineer = IfcRoleEnum.COMMISSIONINGENGINEER + + +engineer = IfcRoleEnum.ENGINEER + + +owner = IfcRoleEnum.OWNER + + +consultant = IfcRoleEnum.CONSULTANT + + +constructionmanager = IfcRoleEnum.CONSTRUCTIONMANAGER + + +fieldconstructionmanager = IfcRoleEnum.FIELDCONSTRUCTIONMANAGER + + +reseller = IfcRoleEnum.RESELLER + + +userdefined = IfcRoleEnum.USERDEFINED + + +IfcRoofTypeEnum = enum_namespace() + + +flat_roof = IfcRoofTypeEnum.FLAT_ROOF + + +shed_roof = IfcRoofTypeEnum.SHED_ROOF + + +gable_roof = IfcRoofTypeEnum.GABLE_ROOF + + +hip_roof = IfcRoofTypeEnum.HIP_ROOF + + +hipped_gable_roof = IfcRoofTypeEnum.HIPPED_GABLE_ROOF + + +gambrel_roof = IfcRoofTypeEnum.GAMBREL_ROOF + + +mansard_roof = IfcRoofTypeEnum.MANSARD_ROOF + + +barrel_roof = IfcRoofTypeEnum.BARREL_ROOF + + +rainbow_roof = IfcRoofTypeEnum.RAINBOW_ROOF + + +butterfly_roof = IfcRoofTypeEnum.BUTTERFLY_ROOF + + +pavilion_roof = IfcRoofTypeEnum.PAVILION_ROOF + + +dome_roof = IfcRoofTypeEnum.DOME_ROOF + + +freeform = IfcRoofTypeEnum.FREEFORM + + +userdefined = IfcRoofTypeEnum.USERDEFINED + + +notdefined = IfcRoofTypeEnum.NOTDEFINED + + +IfcSIPrefix = enum_namespace() + + +exa = IfcSIPrefix.EXA + + +peta = IfcSIPrefix.PETA + + +tera = IfcSIPrefix.TERA + + +giga = IfcSIPrefix.GIGA + + +mega = IfcSIPrefix.MEGA + + +kilo = IfcSIPrefix.KILO + + +hecto = IfcSIPrefix.HECTO + + +deca = IfcSIPrefix.DECA + + +deci = IfcSIPrefix.DECI + + +centi = IfcSIPrefix.CENTI + + +milli = IfcSIPrefix.MILLI + + +micro = IfcSIPrefix.MICRO + + +nano = IfcSIPrefix.NANO + + +pico = IfcSIPrefix.PICO + + +femto = IfcSIPrefix.FEMTO + + +atto = IfcSIPrefix.ATTO + + +IfcSIUnitName = enum_namespace() + + +ampere = IfcSIUnitName.AMPERE + + +becquerel = IfcSIUnitName.BECQUEREL + + +candela = IfcSIUnitName.CANDELA + + +coulomb = IfcSIUnitName.COULOMB + + +cubic_metre = IfcSIUnitName.CUBIC_METRE + + +degree_celsius = IfcSIUnitName.DEGREE_CELSIUS + + +farad = IfcSIUnitName.FARAD + + +gram = IfcSIUnitName.GRAM + + +gray = IfcSIUnitName.GRAY + + +henry = IfcSIUnitName.HENRY + + +hertz = IfcSIUnitName.HERTZ + + +joule = IfcSIUnitName.JOULE + + +kelvin = IfcSIUnitName.KELVIN + + +lumen = IfcSIUnitName.LUMEN + + +lux = IfcSIUnitName.LUX + + +metre = IfcSIUnitName.METRE + + +mole = IfcSIUnitName.MOLE + + +newton = IfcSIUnitName.NEWTON + + +ohm = IfcSIUnitName.OHM + + +pascal = IfcSIUnitName.PASCAL + + +radian = IfcSIUnitName.RADIAN + + +second = IfcSIUnitName.SECOND + + +siemens = IfcSIUnitName.SIEMENS + + +sievert = IfcSIUnitName.SIEVERT + + +square_metre = IfcSIUnitName.SQUARE_METRE + + +steradian = IfcSIUnitName.STERADIAN + + +tesla = IfcSIUnitName.TESLA + + +volt = IfcSIUnitName.VOLT + + +watt = IfcSIUnitName.WATT + + +weber = IfcSIUnitName.WEBER + + +IfcSanitaryTerminalTypeEnum = enum_namespace() + + +bath = IfcSanitaryTerminalTypeEnum.BATH + + +bidet = IfcSanitaryTerminalTypeEnum.BIDET + + +cistern = IfcSanitaryTerminalTypeEnum.CISTERN + + +shower = IfcSanitaryTerminalTypeEnum.SHOWER + + +sink = IfcSanitaryTerminalTypeEnum.SINK + + +sanitaryfountain = IfcSanitaryTerminalTypeEnum.SANITARYFOUNTAIN + + +toiletpan = IfcSanitaryTerminalTypeEnum.TOILETPAN + + +urinal = IfcSanitaryTerminalTypeEnum.URINAL + + +washhandbasin = IfcSanitaryTerminalTypeEnum.WASHHANDBASIN + + +wcseat = IfcSanitaryTerminalTypeEnum.WCSEAT + + +userdefined = IfcSanitaryTerminalTypeEnum.USERDEFINED + + +notdefined = IfcSanitaryTerminalTypeEnum.NOTDEFINED + + +IfcSectionTypeEnum = enum_namespace() + + +uniform = IfcSectionTypeEnum.UNIFORM + + +tapered = IfcSectionTypeEnum.TAPERED + + +IfcSensorTypeEnum = enum_namespace() + + +cosensor = IfcSensorTypeEnum.COSENSOR + + +co2sensor = IfcSensorTypeEnum.CO2SENSOR + + +conductancesensor = IfcSensorTypeEnum.CONDUCTANCESENSOR + + +contactsensor = IfcSensorTypeEnum.CONTACTSENSOR + + +firesensor = IfcSensorTypeEnum.FIRESENSOR + + +flowsensor = IfcSensorTypeEnum.FLOWSENSOR + + +frostsensor = IfcSensorTypeEnum.FROSTSENSOR + + +gassensor = IfcSensorTypeEnum.GASSENSOR + + +heatsensor = IfcSensorTypeEnum.HEATSENSOR + + +humiditysensor = IfcSensorTypeEnum.HUMIDITYSENSOR + + +identifiersensor = IfcSensorTypeEnum.IDENTIFIERSENSOR + + +ionconcentrationsensor = IfcSensorTypeEnum.IONCONCENTRATIONSENSOR + + +levelsensor = IfcSensorTypeEnum.LEVELSENSOR + + +lightsensor = IfcSensorTypeEnum.LIGHTSENSOR + + +moisturesensor = IfcSensorTypeEnum.MOISTURESENSOR + + +movementsensor = IfcSensorTypeEnum.MOVEMENTSENSOR + + +phsensor = IfcSensorTypeEnum.PHSENSOR + + +pressuresensor = IfcSensorTypeEnum.PRESSURESENSOR + + +radiationsensor = IfcSensorTypeEnum.RADIATIONSENSOR + + +radioactivitysensor = IfcSensorTypeEnum.RADIOACTIVITYSENSOR + + +smokesensor = IfcSensorTypeEnum.SMOKESENSOR + + +soundsensor = IfcSensorTypeEnum.SOUNDSENSOR + + +temperaturesensor = IfcSensorTypeEnum.TEMPERATURESENSOR + + +windsensor = IfcSensorTypeEnum.WINDSENSOR + + +earthquakesensor = IfcSensorTypeEnum.EARTHQUAKESENSOR + + +foreignobjectdetectionsensor = IfcSensorTypeEnum.FOREIGNOBJECTDETECTIONSENSOR + + +obstaclesensor = IfcSensorTypeEnum.OBSTACLESENSOR + + +rainsensor = IfcSensorTypeEnum.RAINSENSOR + + +snowdepthsensor = IfcSensorTypeEnum.SNOWDEPTHSENSOR + + +trainsensor = IfcSensorTypeEnum.TRAINSENSOR + + +turnoutclosuresensor = IfcSensorTypeEnum.TURNOUTCLOSURESENSOR + + +wheelsensor = IfcSensorTypeEnum.WHEELSENSOR + + +userdefined = IfcSensorTypeEnum.USERDEFINED + + +notdefined = IfcSensorTypeEnum.NOTDEFINED + + +IfcSequenceEnum = enum_namespace() + + +start_start = IfcSequenceEnum.START_START + + +start_finish = IfcSequenceEnum.START_FINISH + + +finish_start = IfcSequenceEnum.FINISH_START + + +finish_finish = IfcSequenceEnum.FINISH_FINISH + + +userdefined = IfcSequenceEnum.USERDEFINED + + +notdefined = IfcSequenceEnum.NOTDEFINED + + +IfcShadingDeviceTypeEnum = enum_namespace() + + +jalousie = IfcShadingDeviceTypeEnum.JALOUSIE + + +shutter = IfcShadingDeviceTypeEnum.SHUTTER + + +awning = IfcShadingDeviceTypeEnum.AWNING + + +userdefined = IfcShadingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcShadingDeviceTypeEnum.NOTDEFINED + + +IfcSignTypeEnum = enum_namespace() + + +marker = IfcSignTypeEnum.MARKER + + +pictoral = IfcSignTypeEnum.PICTORAL + + +mirror = IfcSignTypeEnum.MIRROR + + +userdefined = IfcSignTypeEnum.USERDEFINED + + +notdefined = IfcSignTypeEnum.NOTDEFINED + + +IfcSignalTypeEnum = enum_namespace() + + +visual = IfcSignalTypeEnum.VISUAL + + +audio = IfcSignalTypeEnum.AUDIO + + +mixed = IfcSignalTypeEnum.MIXED + + +userdefined = IfcSignalTypeEnum.USERDEFINED + + +notdefined = IfcSignalTypeEnum.NOTDEFINED + + +IfcSimplePropertyTemplateTypeEnum = enum_namespace() + + +p_singlevalue = IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE + + +p_enumeratedvalue = IfcSimplePropertyTemplateTypeEnum.P_ENUMERATEDVALUE + + +p_boundedvalue = IfcSimplePropertyTemplateTypeEnum.P_BOUNDEDVALUE + + +p_listvalue = IfcSimplePropertyTemplateTypeEnum.P_LISTVALUE + + +p_tablevalue = IfcSimplePropertyTemplateTypeEnum.P_TABLEVALUE + + +p_referencevalue = IfcSimplePropertyTemplateTypeEnum.P_REFERENCEVALUE + + +q_length = IfcSimplePropertyTemplateTypeEnum.Q_LENGTH + + +q_area = IfcSimplePropertyTemplateTypeEnum.Q_AREA + + +q_volume = IfcSimplePropertyTemplateTypeEnum.Q_VOLUME + + +q_count = IfcSimplePropertyTemplateTypeEnum.Q_COUNT + + +q_weight = IfcSimplePropertyTemplateTypeEnum.Q_WEIGHT + + +q_time = IfcSimplePropertyTemplateTypeEnum.Q_TIME + + +IfcSlabTypeEnum = enum_namespace() + + +floor = IfcSlabTypeEnum.FLOOR + + +roof = IfcSlabTypeEnum.ROOF + + +landing = IfcSlabTypeEnum.LANDING + + +baseslab = IfcSlabTypeEnum.BASESLAB + + +approach_slab = IfcSlabTypeEnum.APPROACH_SLAB + + +paving = IfcSlabTypeEnum.PAVING + + +wearing = IfcSlabTypeEnum.WEARING + + +sidewalk = IfcSlabTypeEnum.SIDEWALK + + +trackslab = IfcSlabTypeEnum.TRACKSLAB + + +userdefined = IfcSlabTypeEnum.USERDEFINED + + +notdefined = IfcSlabTypeEnum.NOTDEFINED + + +IfcSolarDeviceTypeEnum = enum_namespace() + + +solarcollector = IfcSolarDeviceTypeEnum.SOLARCOLLECTOR + + +solarpanel = IfcSolarDeviceTypeEnum.SOLARPANEL + + +userdefined = IfcSolarDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSolarDeviceTypeEnum.NOTDEFINED + + +IfcSpaceHeaterTypeEnum = enum_namespace() + + +convector = IfcSpaceHeaterTypeEnum.CONVECTOR + + +radiator = IfcSpaceHeaterTypeEnum.RADIATOR + + +userdefined = IfcSpaceHeaterTypeEnum.USERDEFINED + + +notdefined = IfcSpaceHeaterTypeEnum.NOTDEFINED + + +IfcSpaceTypeEnum = enum_namespace() + + +space = IfcSpaceTypeEnum.SPACE + + +parking = IfcSpaceTypeEnum.PARKING + + +gfa = IfcSpaceTypeEnum.GFA + + +internal = IfcSpaceTypeEnum.INTERNAL + + +external = IfcSpaceTypeEnum.EXTERNAL + + +berth = IfcSpaceTypeEnum.BERTH + + +userdefined = IfcSpaceTypeEnum.USERDEFINED + + +notdefined = IfcSpaceTypeEnum.NOTDEFINED + + +IfcSpatialZoneTypeEnum = enum_namespace() + + +construction = IfcSpatialZoneTypeEnum.CONSTRUCTION + + +firesafety = IfcSpatialZoneTypeEnum.FIRESAFETY + + +lighting = IfcSpatialZoneTypeEnum.LIGHTING + + +occupancy = IfcSpatialZoneTypeEnum.OCCUPANCY + + +security = IfcSpatialZoneTypeEnum.SECURITY + + +thermal = IfcSpatialZoneTypeEnum.THERMAL + + +transport = IfcSpatialZoneTypeEnum.TRANSPORT + + +ventilation = IfcSpatialZoneTypeEnum.VENTILATION + + +reservation = IfcSpatialZoneTypeEnum.RESERVATION + + +userdefined = IfcSpatialZoneTypeEnum.USERDEFINED + + +notdefined = IfcSpatialZoneTypeEnum.NOTDEFINED + + +IfcStackTerminalTypeEnum = enum_namespace() + + +birdcage = IfcStackTerminalTypeEnum.BIRDCAGE + + +cowl = IfcStackTerminalTypeEnum.COWL + + +rainwaterhopper = IfcStackTerminalTypeEnum.RAINWATERHOPPER + + +userdefined = IfcStackTerminalTypeEnum.USERDEFINED + + +notdefined = IfcStackTerminalTypeEnum.NOTDEFINED + + +IfcStairFlightTypeEnum = enum_namespace() + + +straight = IfcStairFlightTypeEnum.STRAIGHT + + +winder = IfcStairFlightTypeEnum.WINDER + + +spiral = IfcStairFlightTypeEnum.SPIRAL + + +curved = IfcStairFlightTypeEnum.CURVED + + +freeform = IfcStairFlightTypeEnum.FREEFORM + + +userdefined = IfcStairFlightTypeEnum.USERDEFINED + + +notdefined = IfcStairFlightTypeEnum.NOTDEFINED + + +IfcStairTypeEnum = enum_namespace() + + +straight_run_stair = IfcStairTypeEnum.STRAIGHT_RUN_STAIR + + +two_straight_run_stair = IfcStairTypeEnum.TWO_STRAIGHT_RUN_STAIR + + +quarter_winding_stair = IfcStairTypeEnum.QUARTER_WINDING_STAIR + + +quarter_turn_stair = IfcStairTypeEnum.QUARTER_TURN_STAIR + + +half_winding_stair = IfcStairTypeEnum.HALF_WINDING_STAIR + + +half_turn_stair = IfcStairTypeEnum.HALF_TURN_STAIR + + +two_quarter_winding_stair = IfcStairTypeEnum.TWO_QUARTER_WINDING_STAIR + + +two_quarter_turn_stair = IfcStairTypeEnum.TWO_QUARTER_TURN_STAIR + + +three_quarter_winding_stair = IfcStairTypeEnum.THREE_QUARTER_WINDING_STAIR + + +three_quarter_turn_stair = IfcStairTypeEnum.THREE_QUARTER_TURN_STAIR + + +spiral_stair = IfcStairTypeEnum.SPIRAL_STAIR + + +double_return_stair = IfcStairTypeEnum.DOUBLE_RETURN_STAIR + + +curved_run_stair = IfcStairTypeEnum.CURVED_RUN_STAIR + + +two_curved_run_stair = IfcStairTypeEnum.TWO_CURVED_RUN_STAIR + + +ladder = IfcStairTypeEnum.LADDER + + +userdefined = IfcStairTypeEnum.USERDEFINED + + +notdefined = IfcStairTypeEnum.NOTDEFINED + + +IfcStateEnum = enum_namespace() + + +readwrite = IfcStateEnum.READWRITE + + +readonly = IfcStateEnum.READONLY + + +locked = IfcStateEnum.LOCKED + + +readwritelocked = IfcStateEnum.READWRITELOCKED + + +readonlylocked = IfcStateEnum.READONLYLOCKED + + +IfcStructuralCurveActivityTypeEnum = enum_namespace() + + +const = IfcStructuralCurveActivityTypeEnum.CONST + + +linear = IfcStructuralCurveActivityTypeEnum.LINEAR + + +polygonal = IfcStructuralCurveActivityTypeEnum.POLYGONAL + + +equidistant = IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + +sinus = IfcStructuralCurveActivityTypeEnum.SINUS + + +parabola = IfcStructuralCurveActivityTypeEnum.PARABOLA + + +discrete = IfcStructuralCurveActivityTypeEnum.DISCRETE + + +userdefined = IfcStructuralCurveActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveActivityTypeEnum.NOTDEFINED + + +IfcStructuralCurveMemberTypeEnum = enum_namespace() + + +rigid_joined_member = IfcStructuralCurveMemberTypeEnum.RIGID_JOINED_MEMBER + + +pin_joined_member = IfcStructuralCurveMemberTypeEnum.PIN_JOINED_MEMBER + + +cable = IfcStructuralCurveMemberTypeEnum.CABLE + + +tension_member = IfcStructuralCurveMemberTypeEnum.TENSION_MEMBER + + +compression_member = IfcStructuralCurveMemberTypeEnum.COMPRESSION_MEMBER + + +userdefined = IfcStructuralCurveMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveMemberTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceActivityTypeEnum = enum_namespace() + + +const = IfcStructuralSurfaceActivityTypeEnum.CONST + + +bilinear = IfcStructuralSurfaceActivityTypeEnum.BILINEAR + + +discrete = IfcStructuralSurfaceActivityTypeEnum.DISCRETE + + +isocontour = IfcStructuralSurfaceActivityTypeEnum.ISOCONTOUR + + +userdefined = IfcStructuralSurfaceActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceActivityTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceMemberTypeEnum = enum_namespace() + + +bending_element = IfcStructuralSurfaceMemberTypeEnum.BENDING_ELEMENT + + +membrane_element = IfcStructuralSurfaceMemberTypeEnum.MEMBRANE_ELEMENT + + +shell = IfcStructuralSurfaceMemberTypeEnum.SHELL + + +userdefined = IfcStructuralSurfaceMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceMemberTypeEnum.NOTDEFINED + + +IfcSubContractResourceTypeEnum = enum_namespace() + + +purchase = IfcSubContractResourceTypeEnum.PURCHASE + + +work = IfcSubContractResourceTypeEnum.WORK + + +userdefined = IfcSubContractResourceTypeEnum.USERDEFINED + + +notdefined = IfcSubContractResourceTypeEnum.NOTDEFINED + + +IfcSurfaceFeatureTypeEnum = enum_namespace() + + +mark = IfcSurfaceFeatureTypeEnum.MARK + + +tag = IfcSurfaceFeatureTypeEnum.TAG + + +treatment = IfcSurfaceFeatureTypeEnum.TREATMENT + + +defect = IfcSurfaceFeatureTypeEnum.DEFECT + + +hatchmarking = IfcSurfaceFeatureTypeEnum.HATCHMARKING + + +linemarking = IfcSurfaceFeatureTypeEnum.LINEMARKING + + +pavementsurfacemarking = IfcSurfaceFeatureTypeEnum.PAVEMENTSURFACEMARKING + + +symbolmarking = IfcSurfaceFeatureTypeEnum.SYMBOLMARKING + + +nonskidsurfacing = IfcSurfaceFeatureTypeEnum.NONSKIDSURFACING + + +rumblestrip = IfcSurfaceFeatureTypeEnum.RUMBLESTRIP + + +transverserumblestrip = IfcSurfaceFeatureTypeEnum.TRANSVERSERUMBLESTRIP + + +userdefined = IfcSurfaceFeatureTypeEnum.USERDEFINED + + +notdefined = IfcSurfaceFeatureTypeEnum.NOTDEFINED + + +IfcSurfaceSide = enum_namespace() + + +positive = IfcSurfaceSide.POSITIVE + + +negative = IfcSurfaceSide.NEGATIVE + + +both = IfcSurfaceSide.BOTH + + +IfcSwitchingDeviceTypeEnum = enum_namespace() + + +contactor = IfcSwitchingDeviceTypeEnum.CONTACTOR + + +dimmerswitch = IfcSwitchingDeviceTypeEnum.DIMMERSWITCH + + +emergencystop = IfcSwitchingDeviceTypeEnum.EMERGENCYSTOP + + +keypad = IfcSwitchingDeviceTypeEnum.KEYPAD + + +momentaryswitch = IfcSwitchingDeviceTypeEnum.MOMENTARYSWITCH + + +selectorswitch = IfcSwitchingDeviceTypeEnum.SELECTORSWITCH + + +starter = IfcSwitchingDeviceTypeEnum.STARTER + + +switchdisconnector = IfcSwitchingDeviceTypeEnum.SWITCHDISCONNECTOR + + +toggleswitch = IfcSwitchingDeviceTypeEnum.TOGGLESWITCH + + +relay = IfcSwitchingDeviceTypeEnum.RELAY + + +start_and_stop_equipment = IfcSwitchingDeviceTypeEnum.START_AND_STOP_EQUIPMENT + + +userdefined = IfcSwitchingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSwitchingDeviceTypeEnum.NOTDEFINED + + +IfcSystemFurnitureElementTypeEnum = enum_namespace() + + +panel = IfcSystemFurnitureElementTypeEnum.PANEL + + +worksurface = IfcSystemFurnitureElementTypeEnum.WORKSURFACE + + +subrack = IfcSystemFurnitureElementTypeEnum.SUBRACK + + +userdefined = IfcSystemFurnitureElementTypeEnum.USERDEFINED + + +notdefined = IfcSystemFurnitureElementTypeEnum.NOTDEFINED + + +IfcTankTypeEnum = enum_namespace() + + +basin = IfcTankTypeEnum.BASIN + + +breakpressure = IfcTankTypeEnum.BREAKPRESSURE + + +expansion = IfcTankTypeEnum.EXPANSION + + +feedandexpansion = IfcTankTypeEnum.FEEDANDEXPANSION + + +pressurevessel = IfcTankTypeEnum.PRESSUREVESSEL + + +storage = IfcTankTypeEnum.STORAGE + + +vessel = IfcTankTypeEnum.VESSEL + + +oilretentiontray = IfcTankTypeEnum.OILRETENTIONTRAY + + +userdefined = IfcTankTypeEnum.USERDEFINED + + +notdefined = IfcTankTypeEnum.NOTDEFINED + + +IfcTaskDurationEnum = enum_namespace() + + +elapsedtime = IfcTaskDurationEnum.ELAPSEDTIME + + +worktime = IfcTaskDurationEnum.WORKTIME + + +notdefined = IfcTaskDurationEnum.NOTDEFINED + + +IfcTaskTypeEnum = enum_namespace() + + +attendance = IfcTaskTypeEnum.ATTENDANCE + + +construction = IfcTaskTypeEnum.CONSTRUCTION + + +demolition = IfcTaskTypeEnum.DEMOLITION + + +dismantle = IfcTaskTypeEnum.DISMANTLE + + +disposal = IfcTaskTypeEnum.DISPOSAL + + +installation = IfcTaskTypeEnum.INSTALLATION + + +logistic = IfcTaskTypeEnum.LOGISTIC + + +maintenance = IfcTaskTypeEnum.MAINTENANCE + + +move = IfcTaskTypeEnum.MOVE + + +operation = IfcTaskTypeEnum.OPERATION + + +removal = IfcTaskTypeEnum.REMOVAL + + +renovation = IfcTaskTypeEnum.RENOVATION + + +userdefined = IfcTaskTypeEnum.USERDEFINED + + +notdefined = IfcTaskTypeEnum.NOTDEFINED + + +IfcTendonAnchorTypeEnum = enum_namespace() + + +coupler = IfcTendonAnchorTypeEnum.COUPLER + + +fixed_end = IfcTendonAnchorTypeEnum.FIXED_END + + +tensioning_end = IfcTendonAnchorTypeEnum.TENSIONING_END + + +userdefined = IfcTendonAnchorTypeEnum.USERDEFINED + + +notdefined = IfcTendonAnchorTypeEnum.NOTDEFINED + + +IfcTendonConduitTypeEnum = enum_namespace() + + +duct = IfcTendonConduitTypeEnum.DUCT + + +coupler = IfcTendonConduitTypeEnum.COUPLER + + +grouting_duct = IfcTendonConduitTypeEnum.GROUTING_DUCT + + +trumpet = IfcTendonConduitTypeEnum.TRUMPET + + +diabolo = IfcTendonConduitTypeEnum.DIABOLO + + +userdefined = IfcTendonConduitTypeEnum.USERDEFINED + + +notdefined = IfcTendonConduitTypeEnum.NOTDEFINED + + +IfcTendonTypeEnum = enum_namespace() + + +bar = IfcTendonTypeEnum.BAR + + +coated = IfcTendonTypeEnum.COATED + + +strand = IfcTendonTypeEnum.STRAND + + +wire = IfcTendonTypeEnum.WIRE + + +userdefined = IfcTendonTypeEnum.USERDEFINED + + +notdefined = IfcTendonTypeEnum.NOTDEFINED + + +IfcTextPath = enum_namespace() + + +left = IfcTextPath.LEFT + + +right = IfcTextPath.RIGHT + + +up = IfcTextPath.UP + + +down = IfcTextPath.DOWN + + +IfcTimeSeriesDataTypeEnum = enum_namespace() + + +continuous = IfcTimeSeriesDataTypeEnum.CONTINUOUS + + +discrete = IfcTimeSeriesDataTypeEnum.DISCRETE + + +discretebinary = IfcTimeSeriesDataTypeEnum.DISCRETEBINARY + + +piecewisebinary = IfcTimeSeriesDataTypeEnum.PIECEWISEBINARY + + +piecewiseconstant = IfcTimeSeriesDataTypeEnum.PIECEWISECONSTANT + + +piecewisecontinuous = IfcTimeSeriesDataTypeEnum.PIECEWISECONTINUOUS + + +notdefined = IfcTimeSeriesDataTypeEnum.NOTDEFINED + + +IfcTrackElementTypeEnum = enum_namespace() + + +trackendofalignment = IfcTrackElementTypeEnum.TRACKENDOFALIGNMENT + + +blockingdevice = IfcTrackElementTypeEnum.BLOCKINGDEVICE + + +vehiclestop = IfcTrackElementTypeEnum.VEHICLESTOP + + +sleeper = IfcTrackElementTypeEnum.SLEEPER + + +half_set_of_blades = IfcTrackElementTypeEnum.HALF_SET_OF_BLADES + + +speedregulator = IfcTrackElementTypeEnum.SPEEDREGULATOR + + +derailer = IfcTrackElementTypeEnum.DERAILER + + +frog = IfcTrackElementTypeEnum.FROG + + +userdefined = IfcTrackElementTypeEnum.USERDEFINED + + +notdefined = IfcTrackElementTypeEnum.NOTDEFINED + + +IfcTransformerTypeEnum = enum_namespace() + + +current = IfcTransformerTypeEnum.CURRENT + + +frequency = IfcTransformerTypeEnum.FREQUENCY + + +inverter = IfcTransformerTypeEnum.INVERTER + + +rectifier = IfcTransformerTypeEnum.RECTIFIER + + +voltage = IfcTransformerTypeEnum.VOLTAGE + + +chopper = IfcTransformerTypeEnum.CHOPPER + + +combined = IfcTransformerTypeEnum.COMBINED + + +userdefined = IfcTransformerTypeEnum.USERDEFINED + + +notdefined = IfcTransformerTypeEnum.NOTDEFINED + + +IfcTransitionCode = enum_namespace() + + +discontinuous = IfcTransitionCode.DISCONTINUOUS + + +continuous = IfcTransitionCode.CONTINUOUS + + +contsamegradient = IfcTransitionCode.CONTSAMEGRADIENT + + +contsamegradientsamecurvature = IfcTransitionCode.CONTSAMEGRADIENTSAMECURVATURE + + +IfcTransportElementFixedTypeEnum = enum_namespace() + + +elevator = IfcTransportElementFixedTypeEnum.ELEVATOR + + +escalator = IfcTransportElementFixedTypeEnum.ESCALATOR + + +movingwalkway = IfcTransportElementFixedTypeEnum.MOVINGWALKWAY + + +craneway = IfcTransportElementFixedTypeEnum.CRANEWAY + + +liftinggear = IfcTransportElementFixedTypeEnum.LIFTINGGEAR + + +haulinggear = IfcTransportElementFixedTypeEnum.HAULINGGEAR + + +userdefined = IfcTransportElementFixedTypeEnum.USERDEFINED + + +notdefined = IfcTransportElementFixedTypeEnum.NOTDEFINED + + +IfcTransportElementNonFixedTypeEnum = enum_namespace() + + +vehicle = IfcTransportElementNonFixedTypeEnum.VEHICLE + + +vehicletracked = IfcTransportElementNonFixedTypeEnum.VEHICLETRACKED + + +rollingstock = IfcTransportElementNonFixedTypeEnum.ROLLINGSTOCK + + +vehiclewheeled = IfcTransportElementNonFixedTypeEnum.VEHICLEWHEELED + + +vehicleair = IfcTransportElementNonFixedTypeEnum.VEHICLEAIR + + +cargo = IfcTransportElementNonFixedTypeEnum.CARGO + + +vehiclemarine = IfcTransportElementNonFixedTypeEnum.VEHICLEMARINE + + +userdefined = IfcTransportElementNonFixedTypeEnum.USERDEFINED + + +notdefined = IfcTransportElementNonFixedTypeEnum.NOTDEFINED + + +IfcTrimmingPreference = enum_namespace() + + +cartesian = IfcTrimmingPreference.CARTESIAN + + +parameter = IfcTrimmingPreference.PARAMETER + + +unspecified = IfcTrimmingPreference.UNSPECIFIED + + +IfcTubeBundleTypeEnum = enum_namespace() + + +finned = IfcTubeBundleTypeEnum.FINNED + + +userdefined = IfcTubeBundleTypeEnum.USERDEFINED + + +notdefined = IfcTubeBundleTypeEnum.NOTDEFINED + + +IfcUnitEnum = enum_namespace() + + +absorbeddoseunit = IfcUnitEnum.ABSORBEDDOSEUNIT + + +amountofsubstanceunit = IfcUnitEnum.AMOUNTOFSUBSTANCEUNIT + + +areaunit = IfcUnitEnum.AREAUNIT + + +doseequivalentunit = IfcUnitEnum.DOSEEQUIVALENTUNIT + + +electriccapacitanceunit = IfcUnitEnum.ELECTRICCAPACITANCEUNIT + + +electricchargeunit = IfcUnitEnum.ELECTRICCHARGEUNIT + + +electricconductanceunit = IfcUnitEnum.ELECTRICCONDUCTANCEUNIT + + +electriccurrentunit = IfcUnitEnum.ELECTRICCURRENTUNIT + + +electricresistanceunit = IfcUnitEnum.ELECTRICRESISTANCEUNIT + + +electricvoltageunit = IfcUnitEnum.ELECTRICVOLTAGEUNIT + + +energyunit = IfcUnitEnum.ENERGYUNIT + + +forceunit = IfcUnitEnum.FORCEUNIT + + +frequencyunit = IfcUnitEnum.FREQUENCYUNIT + + +illuminanceunit = IfcUnitEnum.ILLUMINANCEUNIT + + +inductanceunit = IfcUnitEnum.INDUCTANCEUNIT + + +lengthunit = IfcUnitEnum.LENGTHUNIT + + +luminousfluxunit = IfcUnitEnum.LUMINOUSFLUXUNIT + + +luminousintensityunit = IfcUnitEnum.LUMINOUSINTENSITYUNIT + + +magneticfluxdensityunit = IfcUnitEnum.MAGNETICFLUXDENSITYUNIT + + +magneticfluxunit = IfcUnitEnum.MAGNETICFLUXUNIT + + +massunit = IfcUnitEnum.MASSUNIT + + +planeangleunit = IfcUnitEnum.PLANEANGLEUNIT + + +powerunit = IfcUnitEnum.POWERUNIT + + +pressureunit = IfcUnitEnum.PRESSUREUNIT + + +radioactivityunit = IfcUnitEnum.RADIOACTIVITYUNIT + + +solidangleunit = IfcUnitEnum.SOLIDANGLEUNIT + + +thermodynamictemperatureunit = IfcUnitEnum.THERMODYNAMICTEMPERATUREUNIT + + +timeunit = IfcUnitEnum.TIMEUNIT + + +volumeunit = IfcUnitEnum.VOLUMEUNIT + + +userdefined = IfcUnitEnum.USERDEFINED + + +IfcUnitaryControlElementTypeEnum = enum_namespace() + + +alarmpanel = IfcUnitaryControlElementTypeEnum.ALARMPANEL + + +controlpanel = IfcUnitaryControlElementTypeEnum.CONTROLPANEL + + +gasdetectionpanel = IfcUnitaryControlElementTypeEnum.GASDETECTIONPANEL + + +indicatorpanel = IfcUnitaryControlElementTypeEnum.INDICATORPANEL + + +mimicpanel = IfcUnitaryControlElementTypeEnum.MIMICPANEL + + +humidistat = IfcUnitaryControlElementTypeEnum.HUMIDISTAT + + +thermostat = IfcUnitaryControlElementTypeEnum.THERMOSTAT + + +weatherstation = IfcUnitaryControlElementTypeEnum.WEATHERSTATION + + +combined = IfcUnitaryControlElementTypeEnum.COMBINED + + +userdefined = IfcUnitaryControlElementTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryControlElementTypeEnum.NOTDEFINED + + +IfcUnitaryEquipmentTypeEnum = enum_namespace() + + +airhandler = IfcUnitaryEquipmentTypeEnum.AIRHANDLER + + +airconditioningunit = IfcUnitaryEquipmentTypeEnum.AIRCONDITIONINGUNIT + + +dehumidifier = IfcUnitaryEquipmentTypeEnum.DEHUMIDIFIER + + +splitsystem = IfcUnitaryEquipmentTypeEnum.SPLITSYSTEM + + +rooftopunit = IfcUnitaryEquipmentTypeEnum.ROOFTOPUNIT + + +userdefined = IfcUnitaryEquipmentTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryEquipmentTypeEnum.NOTDEFINED + + +IfcValveTypeEnum = enum_namespace() + + +airrelease = IfcValveTypeEnum.AIRRELEASE + + +antivacuum = IfcValveTypeEnum.ANTIVACUUM + + +changeover = IfcValveTypeEnum.CHANGEOVER + + +check = IfcValveTypeEnum.CHECK + + +commissioning = IfcValveTypeEnum.COMMISSIONING + + +diverting = IfcValveTypeEnum.DIVERTING + + +drawoffcock = IfcValveTypeEnum.DRAWOFFCOCK + + +doublecheck = IfcValveTypeEnum.DOUBLECHECK + + +doubleregulating = IfcValveTypeEnum.DOUBLEREGULATING + + +faucet = IfcValveTypeEnum.FAUCET + + +flushing = IfcValveTypeEnum.FLUSHING + + +gascock = IfcValveTypeEnum.GASCOCK + + +gastap = IfcValveTypeEnum.GASTAP + + +isolating = IfcValveTypeEnum.ISOLATING + + +mixing = IfcValveTypeEnum.MIXING + + +pressurereducing = IfcValveTypeEnum.PRESSUREREDUCING + + +pressurerelief = IfcValveTypeEnum.PRESSURERELIEF + + +regulating = IfcValveTypeEnum.REGULATING + + +safetycutoff = IfcValveTypeEnum.SAFETYCUTOFF + + +steamtrap = IfcValveTypeEnum.STEAMTRAP + + +stopcock = IfcValveTypeEnum.STOPCOCK + + +userdefined = IfcValveTypeEnum.USERDEFINED + + +notdefined = IfcValveTypeEnum.NOTDEFINED + + +IfcVibrationDamperTypeEnum = enum_namespace() + + +bending_yield = IfcVibrationDamperTypeEnum.BENDING_YIELD + + +shear_yield = IfcVibrationDamperTypeEnum.SHEAR_YIELD + + +axial_yield = IfcVibrationDamperTypeEnum.AXIAL_YIELD + + +friction = IfcVibrationDamperTypeEnum.FRICTION + + +viscous = IfcVibrationDamperTypeEnum.VISCOUS + + +rubber = IfcVibrationDamperTypeEnum.RUBBER + + +userdefined = IfcVibrationDamperTypeEnum.USERDEFINED + + +notdefined = IfcVibrationDamperTypeEnum.NOTDEFINED + + +IfcVibrationIsolatorTypeEnum = enum_namespace() + + +compression = IfcVibrationIsolatorTypeEnum.COMPRESSION + + +spring = IfcVibrationIsolatorTypeEnum.SPRING + + +base = IfcVibrationIsolatorTypeEnum.BASE + + +userdefined = IfcVibrationIsolatorTypeEnum.USERDEFINED + + +notdefined = IfcVibrationIsolatorTypeEnum.NOTDEFINED + + +IfcVoidingFeatureTypeEnum = enum_namespace() + + +cutout = IfcVoidingFeatureTypeEnum.CUTOUT + + +notch = IfcVoidingFeatureTypeEnum.NOTCH + + +hole = IfcVoidingFeatureTypeEnum.HOLE + + +miter = IfcVoidingFeatureTypeEnum.MITER + + +chamfer = IfcVoidingFeatureTypeEnum.CHAMFER + + +edge = IfcVoidingFeatureTypeEnum.EDGE + + +userdefined = IfcVoidingFeatureTypeEnum.USERDEFINED + + +notdefined = IfcVoidingFeatureTypeEnum.NOTDEFINED + + +IfcWallTypeEnum = enum_namespace() + + +movable = IfcWallTypeEnum.MOVABLE + + +parapet = IfcWallTypeEnum.PARAPET + + +partitioning = IfcWallTypeEnum.PARTITIONING + + +plumbingwall = IfcWallTypeEnum.PLUMBINGWALL + + +shear = IfcWallTypeEnum.SHEAR + + +solidwall = IfcWallTypeEnum.SOLIDWALL + + +standard = IfcWallTypeEnum.STANDARD + + +polygonal = IfcWallTypeEnum.POLYGONAL + + +elementedwall = IfcWallTypeEnum.ELEMENTEDWALL + + +retainingwall = IfcWallTypeEnum.RETAININGWALL + + +wavewall = IfcWallTypeEnum.WAVEWALL + + +userdefined = IfcWallTypeEnum.USERDEFINED + + +notdefined = IfcWallTypeEnum.NOTDEFINED + + +IfcWasteTerminalTypeEnum = enum_namespace() + + +floortrap = IfcWasteTerminalTypeEnum.FLOORTRAP + + +floorwaste = IfcWasteTerminalTypeEnum.FLOORWASTE + + +gullysump = IfcWasteTerminalTypeEnum.GULLYSUMP + + +gullytrap = IfcWasteTerminalTypeEnum.GULLYTRAP + + +roofdrain = IfcWasteTerminalTypeEnum.ROOFDRAIN + + +wastedisposalunit = IfcWasteTerminalTypeEnum.WASTEDISPOSALUNIT + + +wastetrap = IfcWasteTerminalTypeEnum.WASTETRAP + + +userdefined = IfcWasteTerminalTypeEnum.USERDEFINED + + +notdefined = IfcWasteTerminalTypeEnum.NOTDEFINED + + +IfcWindowPanelOperationEnum = enum_namespace() + + +sidehungrighthand = IfcWindowPanelOperationEnum.SIDEHUNGRIGHTHAND + + +sidehunglefthand = IfcWindowPanelOperationEnum.SIDEHUNGLEFTHAND + + +tiltandturnrighthand = IfcWindowPanelOperationEnum.TILTANDTURNRIGHTHAND + + +tiltandturnlefthand = IfcWindowPanelOperationEnum.TILTANDTURNLEFTHAND + + +tophung = IfcWindowPanelOperationEnum.TOPHUNG + + +bottomhung = IfcWindowPanelOperationEnum.BOTTOMHUNG + + +pivothorizontal = IfcWindowPanelOperationEnum.PIVOTHORIZONTAL + + +pivotvertical = IfcWindowPanelOperationEnum.PIVOTVERTICAL + + +slidinghorizontal = IfcWindowPanelOperationEnum.SLIDINGHORIZONTAL + + +slidingvertical = IfcWindowPanelOperationEnum.SLIDINGVERTICAL + + +removablecasement = IfcWindowPanelOperationEnum.REMOVABLECASEMENT + + +fixedcasement = IfcWindowPanelOperationEnum.FIXEDCASEMENT + + +otheroperation = IfcWindowPanelOperationEnum.OTHEROPERATION + + +notdefined = IfcWindowPanelOperationEnum.NOTDEFINED + + +IfcWindowPanelPositionEnum = enum_namespace() + + +left = IfcWindowPanelPositionEnum.LEFT + + +middle = IfcWindowPanelPositionEnum.MIDDLE + + +right = IfcWindowPanelPositionEnum.RIGHT + + +bottom = IfcWindowPanelPositionEnum.BOTTOM + + +top = IfcWindowPanelPositionEnum.TOP + + +notdefined = IfcWindowPanelPositionEnum.NOTDEFINED + + +IfcWindowStyleConstructionEnum = enum_namespace() + + +aluminium = IfcWindowStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcWindowStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcWindowStyleConstructionEnum.STEEL + + +wood = IfcWindowStyleConstructionEnum.WOOD + + +aluminium_wood = IfcWindowStyleConstructionEnum.ALUMINIUM_WOOD + + +plastic = IfcWindowStyleConstructionEnum.PLASTIC + + +other_construction = IfcWindowStyleConstructionEnum.OTHER_CONSTRUCTION + + +notdefined = IfcWindowStyleConstructionEnum.NOTDEFINED + + +IfcWindowStyleOperationEnum = enum_namespace() + + +single_panel = IfcWindowStyleOperationEnum.SINGLE_PANEL + + +double_panel_vertical = IfcWindowStyleOperationEnum.DOUBLE_PANEL_VERTICAL + + +double_panel_horizontal = IfcWindowStyleOperationEnum.DOUBLE_PANEL_HORIZONTAL + + +triple_panel_vertical = IfcWindowStyleOperationEnum.TRIPLE_PANEL_VERTICAL + + +triple_panel_bottom = IfcWindowStyleOperationEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_top = IfcWindowStyleOperationEnum.TRIPLE_PANEL_TOP + + +triple_panel_left = IfcWindowStyleOperationEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowStyleOperationEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_horizontal = IfcWindowStyleOperationEnum.TRIPLE_PANEL_HORIZONTAL + + +userdefined = IfcWindowStyleOperationEnum.USERDEFINED + + +notdefined = IfcWindowStyleOperationEnum.NOTDEFINED + + +IfcWindowTypeEnum = enum_namespace() + + +window = IfcWindowTypeEnum.WINDOW + + +skylight = IfcWindowTypeEnum.SKYLIGHT + + +lightdome = IfcWindowTypeEnum.LIGHTDOME + + +userdefined = IfcWindowTypeEnum.USERDEFINED + + +notdefined = IfcWindowTypeEnum.NOTDEFINED + + +IfcWindowTypePartitioningEnum = enum_namespace() + + +single_panel = IfcWindowTypePartitioningEnum.SINGLE_PANEL + + +double_panel_vertical = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_VERTICAL + + +double_panel_horizontal = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_HORIZONTAL + + +triple_panel_vertical = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_VERTICAL + + +triple_panel_bottom = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_top = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_TOP + + +triple_panel_left = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_horizontal = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_HORIZONTAL + + +userdefined = IfcWindowTypePartitioningEnum.USERDEFINED + + +notdefined = IfcWindowTypePartitioningEnum.NOTDEFINED + + +IfcWorkCalendarTypeEnum = enum_namespace() + + +firstshift = IfcWorkCalendarTypeEnum.FIRSTSHIFT + + +secondshift = IfcWorkCalendarTypeEnum.SECONDSHIFT + + +thirdshift = IfcWorkCalendarTypeEnum.THIRDSHIFT + + +userdefined = IfcWorkCalendarTypeEnum.USERDEFINED + + +notdefined = IfcWorkCalendarTypeEnum.NOTDEFINED + + +IfcWorkPlanTypeEnum = enum_namespace() + + +actual = IfcWorkPlanTypeEnum.ACTUAL + + +baseline = IfcWorkPlanTypeEnum.BASELINE + + +planned = IfcWorkPlanTypeEnum.PLANNED + + +userdefined = IfcWorkPlanTypeEnum.USERDEFINED + + +notdefined = IfcWorkPlanTypeEnum.NOTDEFINED + + +IfcWorkScheduleTypeEnum = enum_namespace() + + +actual = IfcWorkScheduleTypeEnum.ACTUAL + + +baseline = IfcWorkScheduleTypeEnum.BASELINE + + +planned = IfcWorkScheduleTypeEnum.PLANNED + + +userdefined = IfcWorkScheduleTypeEnum.USERDEFINED + + +notdefined = IfcWorkScheduleTypeEnum.NOTDEFINED + + +def IfcActionRequest(*args, **kwargs): return ifcopenshell.create_entity('IfcActionRequest', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcActor(*args, **kwargs): return ifcopenshell.create_entity('IfcActor', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcActorRole(*args, **kwargs): return ifcopenshell.create_entity('IfcActorRole', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcActuator(*args, **kwargs): return ifcopenshell.create_entity('IfcActuator', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcActuatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcActuatorType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcAddress', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAdvancedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrep', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAdvancedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrepWithVoids', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAdvancedFace(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedFace', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAirTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminal', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAirTerminalBox(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBox', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAirTerminalBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBoxType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAirTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAirToAirHeatRecovery(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecovery', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAirToAirHeatRecoveryType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecoveryType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAlarm(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarm', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAlarmType(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarmType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAlignment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAlignmentCant(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCant', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAlignmentCantSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCantSegment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAlignmentHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentHorizontal', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAlignmentHorizontalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentHorizontalSegment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAlignmentParameterSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentParameterSegment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAlignmentSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentSegment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAlignmentVertical(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentVertical', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAlignmentVerticalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentVerticalSegment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAnnotation(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotation', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAnnotationFillArea(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationFillArea', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcApplication(*args, **kwargs): return ifcopenshell.create_entity('IfcApplication', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAppliedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcAppliedValue', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcApproval', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcApprovalRelationship', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcArbitraryClosedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryClosedProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcArbitraryOpenProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryOpenProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcArbitraryProfileDefWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryProfileDefWithVoids', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAsset(*args, **kwargs): return ifcopenshell.create_entity('IfcAsset', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAsymmetricIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcAsymmetricIShapeProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAudioVisualAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualAppliance', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAudioVisualApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualApplianceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAxis1Placement(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis1Placement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAxis2Placement2D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement2D', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAxis2Placement3D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement3D', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcAxis2PlacementLinear(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2PlacementLinear', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBSplineCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurveWithKnots', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBSplineSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurface', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurfaceWithKnots', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcBeam', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBeamStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamStandardCase', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBearing(*args, **kwargs): return ifcopenshell.create_entity('IfcBearing', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBearingType(*args, **kwargs): return ifcopenshell.create_entity('IfcBearingType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBlobTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcBlobTexture', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBlock(*args, **kwargs): return ifcopenshell.create_entity('IfcBlock', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBoiler(*args, **kwargs): return ifcopenshell.create_entity('IfcBoiler', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBoilerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBoilerType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBooleanClippingResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanClippingResult', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBooleanResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanResult', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBorehole(*args, **kwargs): return ifcopenshell.create_entity('IfcBorehole', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBoundaryCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCondition', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBoundaryEdgeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryEdgeCondition', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBoundaryFaceCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryFaceCondition', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBoundaryNodeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeCondition', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBoundaryNodeConditionWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeConditionWarping', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBoundedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedSurface', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBoundingBox(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundingBox', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBoxedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcBoxedHalfSpace', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBridge(*args, **kwargs): return ifcopenshell.create_entity('IfcBridge', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBuilding(*args, **kwargs): return ifcopenshell.create_entity('IfcBuilding', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBuildingElementPart(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPart', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBuildingElementPartType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPartType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBuildingElementProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxy', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBuildingElementProxyType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxyType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBuildingStorey(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingStorey', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBuildingSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingSystem', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBuiltElement(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBuiltElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBuiltSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltSystem', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBurner(*args, **kwargs): return ifcopenshell.create_entity('IfcBurner', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcBurnerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBurnerType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCShapeProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCableCarrierFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFitting', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCableCarrierFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFittingType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCableCarrierSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCableCarrierSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegmentType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCableFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFitting', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCableFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFittingType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCableSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCableSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegmentType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCaissonFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundation', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCaissonFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundationType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCartesianPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPoint', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCartesianPointList(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCartesianPointList2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList2D', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCartesianPointList3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList3D', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCartesianTransformationOperator(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCartesianTransformationOperator2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2D', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCartesianTransformationOperator2DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2DnonUniform', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCartesianTransformationOperator3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3D', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCartesianTransformationOperator3DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3DnonUniform', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCenterLineProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCenterLineProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcChiller(*args, **kwargs): return ifcopenshell.create_entity('IfcChiller', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcChillerType(*args, **kwargs): return ifcopenshell.create_entity('IfcChillerType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcChimney(*args, **kwargs): return ifcopenshell.create_entity('IfcChimney', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcChimneyType(*args, **kwargs): return ifcopenshell.create_entity('IfcChimneyType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCircle(*args, **kwargs): return ifcopenshell.create_entity('IfcCircle', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCircleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleHollowProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCircleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCivilElement(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCivilElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcClassification', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcClassificationReference(*args, **kwargs): return ifcopenshell.create_entity('IfcClassificationReference', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcClosedShell(*args, **kwargs): return ifcopenshell.create_entity('IfcClosedShell', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcClothoid(*args, **kwargs): return ifcopenshell.create_entity('IfcClothoid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCoil(*args, **kwargs): return ifcopenshell.create_entity('IfcCoil', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCoilType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoilType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcColourRgb(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgb', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcColourRgbList(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgbList', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcColourSpecification(*args, **kwargs): return ifcopenshell.create_entity('IfcColourSpecification', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcColumn', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcColumnStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnStandardCase', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcColumnType(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsAppliance', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsApplianceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcComplexProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexProperty', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcComplexPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexPropertyTemplate', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCompositeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCompositeCurveOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveOnSurface', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveSegment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCompositeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCompressor(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressor', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCompressorType(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressorType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCondenser(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenser', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCondenserType(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenserType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConic(*args, **kwargs): return ifcopenshell.create_entity('IfcConic', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConnectedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectedFaceSet', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConnectionCurveGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionCurveGeometry', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConnectionGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionGeometry', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConnectionPointEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointEccentricity', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConnectionPointGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointGeometry', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConnectionSurfaceGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionSurfaceGeometry', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConnectionVolumeGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionVolumeGeometry', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcConstraint', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConstructionEquipmentResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResource', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConstructionEquipmentResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResourceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConstructionMaterialResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResource', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConstructionMaterialResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResourceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConstructionProductResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResource', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConstructionProductResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResourceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConstructionResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResource', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConstructionResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResourceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcContext(*args, **kwargs): return ifcopenshell.create_entity('IfcContext', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcContextDependentUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcContextDependentUnit', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcControl(*args, **kwargs): return ifcopenshell.create_entity('IfcControl', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcController(*args, **kwargs): return ifcopenshell.create_entity('IfcController', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcControllerType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConversionBasedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnit', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConversionBasedUnitWithOffset(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnitWithOffset', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConveyorSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcConveyorSegment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcConveyorSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcConveyorSegmentType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCooledBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeam', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCooledBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeamType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCoolingTower(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTower', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCoolingTowerType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTowerType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCoordinateOperation(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateOperation', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCoordinateReferenceSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateReferenceSystem', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCosine(*args, **kwargs): return ifcopenshell.create_entity('IfcCosine', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCostItem(*args, **kwargs): return ifcopenshell.create_entity('IfcCostItem', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCostSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcCostSchedule', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCostValue(*args, **kwargs): return ifcopenshell.create_entity('IfcCostValue', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCourse(*args, **kwargs): return ifcopenshell.create_entity('IfcCourse', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCourseType(*args, **kwargs): return ifcopenshell.create_entity('IfcCourseType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCovering(*args, **kwargs): return ifcopenshell.create_entity('IfcCovering', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCoveringType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoveringType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCrewResource(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResource', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCrewResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResourceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCsgPrimitive3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgPrimitive3D', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCsgSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgSolid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCurrencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcCurrencyRelationship', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCurtainWall(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWall', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCurtainWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWallType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCurveBoundedPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedPlane', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCurveBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedSurface', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveSegment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCurveStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyle', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCurveStyleFont(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFont', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCurveStyleFontAndScaling(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontAndScaling', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCurveStyleFontPattern(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontPattern', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcCylindricalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCylindricalSurface', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcDamper', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcDamperType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDeepFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundation', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDeepFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundationType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDerivedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDerivedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnit', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDerivedUnitElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnitElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDimensionalExponents(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionalExponents', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDirection(*args, **kwargs): return ifcopenshell.create_entity('IfcDirection', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDirectrixCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcDirectrixCurveSweptAreaSolid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDirectrixDerivedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcDirectrixDerivedReferenceSweptAreaSolid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDirectrixDistanceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcDirectrixDistanceSweptAreaSolid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDiscreteAccessory(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessory', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDiscreteAccessoryType(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessoryType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionBoard', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionBoardType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDistributionChamberElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDistributionChamberElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDistributionCircuit(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionCircuit', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDistributionControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDistributionControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDistributionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDistributionElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDistributionFlowElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDistributionFlowElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDistributionPort(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionPort', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDistributionSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionSystem', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDocumentInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformation', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDocumentInformationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformationRelationship', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDocumentReference(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentReference', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDoor(*args, **kwargs): return ifcopenshell.create_entity('IfcDoor', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDoorLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorLiningProperties', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDoorPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorPanelProperties', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDoorStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorStandardCase', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDoorStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorStyle', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDoorType(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDraughtingPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedColour', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDraughtingPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedCurveFont', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDuctFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFitting', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDuctFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFittingType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDuctSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDuctSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegmentType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDuctSilencer(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencer', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcDuctSilencerType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencerType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEarthworksCut(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksCut', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEarthworksElement(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEarthworksFill(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksFill', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcEdge', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEdgeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEdgeLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeLoop', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElectricAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricAppliance', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElectricApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricApplianceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElectricDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoard', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElectricDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoardType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElectricFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDevice', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElectricFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDeviceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElectricFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowTreatmentDevice', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElectricFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowTreatmentDeviceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElectricGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGenerator', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElectricGeneratorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGeneratorType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElectricMotor(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotor', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElectricMotorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotorType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElectricTimeControl(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControl', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElectricTimeControlType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControlType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElement(*args, **kwargs): return ifcopenshell.create_entity('IfcElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElementAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssembly', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElementAssemblyType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssemblyType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElementComponent(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponent', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElementComponentType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponentType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElementQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcElementQuantity', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcElementarySurface(*args, **kwargs): return ifcopenshell.create_entity('IfcElementarySurface', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEllipse(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipse', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEllipseProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipseProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEnergyConversionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDevice', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEnergyConversionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDeviceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEngine(*args, **kwargs): return ifcopenshell.create_entity('IfcEngine', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEngineType(*args, **kwargs): return ifcopenshell.create_entity('IfcEngineType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEvaporativeCooler(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCooler', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEvaporativeCoolerType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCoolerType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEvaporator(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporator', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEvaporatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporatorType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEvent(*args, **kwargs): return ifcopenshell.create_entity('IfcEvent', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEventTime(*args, **kwargs): return ifcopenshell.create_entity('IfcEventTime', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcEventType(*args, **kwargs): return ifcopenshell.create_entity('IfcEventType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcExtendedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcExtendedProperties', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcExternalInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalInformation', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcExternalReference(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReference', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcExternalReferenceRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReferenceRelationship', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcExternalSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcExternalSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialStructureElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcExternallyDefinedHatchStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedHatchStyle', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcExternallyDefinedSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedSurfaceStyle', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcExternallyDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedTextFont', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcExtrudedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcExtrudedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolidTapered', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFace(*args, **kwargs): return ifcopenshell.create_entity('IfcFace', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFaceBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBasedSurfaceModel', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFaceBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBound', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFaceOuterBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceOuterBound', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFaceSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceSurface', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFacetedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrep', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFacetedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrepWithVoids', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFacility(*args, **kwargs): return ifcopenshell.create_entity('IfcFacility', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFacilityPart(*args, **kwargs): return ifcopenshell.create_entity('IfcFacilityPart', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFailureConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcFailureConnectionCondition', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFan(*args, **kwargs): return ifcopenshell.create_entity('IfcFan', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFanType(*args, **kwargs): return ifcopenshell.create_entity('IfcFanType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcFastener', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFastenerType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFeatureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFeatureElementAddition(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementAddition', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFeatureElementSubtraction(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementSubtraction', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFillAreaStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyle', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFillAreaStyleHatching(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleHatching', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFillAreaStyleTiles(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleTiles', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFilter(*args, **kwargs): return ifcopenshell.create_entity('IfcFilter', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFilterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFilterType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFireSuppressionTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminal', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFireSuppressionTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminalType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFixedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcFixedReferenceSweptAreaSolid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowController(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowController', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowControllerType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFitting', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFittingType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowInstrument(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrument', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowInstrumentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrumentType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowMeter(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeter', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowMeterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeterType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowMovingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDevice', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowMovingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDeviceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegmentType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDevice', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDeviceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminal', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminalType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDevice', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDeviceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFooting(*args, **kwargs): return ifcopenshell.create_entity('IfcFooting', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFootingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFootingType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFurnishingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFurnishingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFurniture(*args, **kwargs): return ifcopenshell.create_entity('IfcFurniture', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcFurnitureType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnitureType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGeographicElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGeographicElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGeometricCurveSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricCurveSet', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGeometricRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationContext', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGeometricRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationItem', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGeometricRepresentationSubContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationSubContext', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGeometricSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricSet', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGeomodel(*args, **kwargs): return ifcopenshell.create_entity('IfcGeomodel', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGeoslice(*args, **kwargs): return ifcopenshell.create_entity('IfcGeoslice', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGeotechnicalAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalAssembly', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGeotechnicalElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGeotechnicalStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalStratum', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGradientCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcGradientCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGrid(*args, **kwargs): return ifcopenshell.create_entity('IfcGrid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGridAxis(*args, **kwargs): return ifcopenshell.create_entity('IfcGridAxis', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGridPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcGridPlacement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcGroup', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcHalfSpaceSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcHalfSpaceSolid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcHeatExchanger(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchanger', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcHeatExchangerType(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchangerType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcHumidifier(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifier', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcHumidifierType(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifierType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcIShapeProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcImageTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcImageTexture', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcImpactProtectionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcImpactProtectionDevice', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcImpactProtectionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcImpactProtectionDeviceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcInclinedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcInclinedReferenceSweptAreaSolid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcIndexedColourMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedColourMap', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcIndexedPolyCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolyCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcIndexedPolygonalFace(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFace', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcIndexedPolygonalFaceWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFaceWithVoids', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcIndexedTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTextureMap', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcIndexedTriangleTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTriangleTextureMap', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcInterceptor(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptor', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcInterceptorType(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptorType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcIntersectionCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIntersectionCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcInventory(*args, **kwargs): return ifcopenshell.create_entity('IfcInventory', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcIrregularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeries', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcIrregularTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeriesValue', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcJunctionBox(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBox', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcJunctionBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBoxType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcKerb(*args, **kwargs): return ifcopenshell.create_entity('IfcKerb', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcKerbType(*args, **kwargs): return ifcopenshell.create_entity('IfcKerbType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcLShapeProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLaborResource(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResource', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLaborResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResourceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLagTime(*args, **kwargs): return ifcopenshell.create_entity('IfcLagTime', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLamp(*args, **kwargs): return ifcopenshell.create_entity('IfcLamp', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLampType(*args, **kwargs): return ifcopenshell.create_entity('IfcLampType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLibraryInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryInformation', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLibraryReference(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryReference', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLightDistributionData(*args, **kwargs): return ifcopenshell.create_entity('IfcLightDistributionData', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLightFixture(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixture', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLightFixtureType(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixtureType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLightIntensityDistribution(*args, **kwargs): return ifcopenshell.create_entity('IfcLightIntensityDistribution', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLightSource(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSource', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLightSourceAmbient(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceAmbient', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLightSourceDirectional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceDirectional', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLightSourceGoniometric(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceGoniometric', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLightSourcePositional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourcePositional', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLightSourceSpot(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceSpot', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLine(*args, **kwargs): return ifcopenshell.create_entity('IfcLine', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLinearElement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLinearPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPlacement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLinearPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPositioningElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLiquidTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcLiquidTerminal', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLiquidTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcLiquidTerminalType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLocalPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLocalPlacement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcLoop', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcManifoldSolidBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcManifoldSolidBrep', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMapConversion(*args, **kwargs): return ifcopenshell.create_entity('IfcMapConversion', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMappedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcMappedItem', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMarineFacility(*args, **kwargs): return ifcopenshell.create_entity('IfcMarineFacility', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterial', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialClassificationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialClassificationRelationship', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialConstituent(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituent', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialConstituentSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituentSet', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinition', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialDefinitionRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinitionRepresentation', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialLayer(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayer', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialLayerSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSet', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialLayerSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSetUsage', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialLayerWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerWithOffsets', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialList(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialList', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialProfile(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfile', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialProfileSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSet', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialProfileSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsage', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialProfileSetUsageTapering(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsageTapering', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialProfileWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileWithOffsets', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProperties', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialRelationship', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMaterialUsageDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialUsageDefinition', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMeasureWithUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMeasureWithUnit', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMechanicalFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastener', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMechanicalFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastenerType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMedicalDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDevice', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMedicalDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDeviceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMember(*args, **kwargs): return ifcopenshell.create_entity('IfcMember', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMemberStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberStandardCase', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMemberType(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMetric(*args, **kwargs): return ifcopenshell.create_entity('IfcMetric', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMirroredProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcMirroredProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMobileTelecommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcMobileTelecommunicationsAppliance', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMobileTelecommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMobileTelecommunicationsApplianceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMonetaryUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMonetaryUnit', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMooringDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMooringDevice', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMooringDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMooringDeviceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMotorConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnection', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcMotorConnectionType(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnectionType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcNamedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcNamedUnit', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcNavigationElement(*args, **kwargs): return ifcopenshell.create_entity('IfcNavigationElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcNavigationElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcNavigationElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcObject(*args, **kwargs): return ifcopenshell.create_entity('IfcObject', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcObjectDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectDefinition', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcObjectPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectPlacement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcObjective(*args, **kwargs): return ifcopenshell.create_entity('IfcObjective', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOccupant(*args, **kwargs): return ifcopenshell.create_entity('IfcOccupant', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOffsetCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOffsetCurve2D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve2D', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOffsetCurve3D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve3D', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOffsetCurveByDistances(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurveByDistances', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOpenCrossProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenCrossProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOpenShell(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenShell', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOpeningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOpeningStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningStandardCase', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganization', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOrganizationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganizationRelationship', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOrientedEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcOrientedEdge', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOuterBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOuterBoundaryCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOutlet(*args, **kwargs): return ifcopenshell.create_entity('IfcOutlet', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOutletType(*args, **kwargs): return ifcopenshell.create_entity('IfcOutletType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcOwnerHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcOwnerHistory', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcParameterizedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcParameterizedProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPath(*args, **kwargs): return ifcopenshell.create_entity('IfcPath', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPavement(*args, **kwargs): return ifcopenshell.create_entity('IfcPavement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPavementType(*args, **kwargs): return ifcopenshell.create_entity('IfcPavementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPcurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPcurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPerformanceHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcPerformanceHistory', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPermeableCoveringProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPermeableCoveringProperties', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPermit(*args, **kwargs): return ifcopenshell.create_entity('IfcPermit', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPerson(*args, **kwargs): return ifcopenshell.create_entity('IfcPerson', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPersonAndOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcPersonAndOrganization', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPhysicalComplexQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalComplexQuantity', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPhysicalQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalQuantity', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPhysicalSimpleQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalSimpleQuantity', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPile(*args, **kwargs): return ifcopenshell.create_entity('IfcPile', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPileType(*args, **kwargs): return ifcopenshell.create_entity('IfcPileType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPipeFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFitting', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPipeFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFittingType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPipeSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPipeSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegmentType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPixelTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcPixelTexture', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcPlacement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPlanarBox(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarBox', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPlanarExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarExtent', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcPlane', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPlant(*args, **kwargs): return ifcopenshell.create_entity('IfcPlant', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPlate(*args, **kwargs): return ifcopenshell.create_entity('IfcPlate', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPlateStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateStandardCase', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPlateType(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcPoint', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPointByDistanceExpression(*args, **kwargs): return ifcopenshell.create_entity('IfcPointByDistanceExpression', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPointOnCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPointOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnSurface', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPolyLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyLoop', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPolygonalBoundedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalBoundedHalfSpace', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPolygonalFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalFaceSet', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPolyline(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyline', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPolynomialCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPolynomialCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPort(*args, **kwargs): return ifcopenshell.create_entity('IfcPort', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcPositioningElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPostalAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcPostalAddress', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedColour', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedCurveFont', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPreDefinedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedItem', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPreDefinedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedProperties', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPreDefinedPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedPropertySet', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPreDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedTextFont', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationItem', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPresentationLayerAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerAssignment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPresentationLayerWithStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerWithStyle', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPresentationStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyle', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProcedure(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedure', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProcedureType(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedureType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcProcess', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcProduct', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProductDefinitionShape(*args, **kwargs): return ifcopenshell.create_entity('IfcProductDefinitionShape', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProductRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcProductRepresentation', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileProperties', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProject(*args, **kwargs): return ifcopenshell.create_entity('IfcProject', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProjectLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectLibrary', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProjectOrder(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectOrder', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProjectedCRS(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectedCRS', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProjectionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectionElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcProperty', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPropertyAbstraction(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyAbstraction', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPropertyBoundedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyBoundedValue', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPropertyDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDefinition', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPropertyDependencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDependencyRelationship', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPropertyEnumeratedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeratedValue', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPropertyEnumeration(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeration', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPropertyListValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyListValue', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPropertyReferenceValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyReferenceValue', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySet', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPropertySetDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetDefinition', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPropertySetTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetTemplate', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPropertySingleValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySingleValue', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPropertyTableValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTableValue', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplate', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPropertyTemplateDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplateDefinition', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProtectiveDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDevice', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnit', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnitType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnitType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProtectiveDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcProxy', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPump(*args, **kwargs): return ifcopenshell.create_entity('IfcPump', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcPumpType(*args, **kwargs): return ifcopenshell.create_entity('IfcPumpType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcQuantityArea(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityArea', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcQuantityCount(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityCount', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcQuantityLength(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityLength', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcQuantitySet(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantitySet', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcQuantityTime(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityTime', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcQuantityVolume(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityVolume', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcQuantityWeight(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityWeight', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRail(*args, **kwargs): return ifcopenshell.create_entity('IfcRail', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRailType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRailing(*args, **kwargs): return ifcopenshell.create_entity('IfcRailing', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRailingType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailingType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRailway(*args, **kwargs): return ifcopenshell.create_entity('IfcRailway', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRamp(*args, **kwargs): return ifcopenshell.create_entity('IfcRamp', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRampFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlight', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRampFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlightType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRampType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRationalBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineCurveWithKnots', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRationalBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineSurfaceWithKnots', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRectangleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleHollowProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRectangularPyramid(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularPyramid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRectangularTrimmedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularTrimmedSurface', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRecurrencePattern(*args, **kwargs): return ifcopenshell.create_entity('IfcRecurrencePattern', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcReference(*args, **kwargs): return ifcopenshell.create_entity('IfcReference', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcReferent(*args, **kwargs): return ifcopenshell.create_entity('IfcReferent', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRegularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcRegularTimeSeries', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcReinforcedSoil(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcedSoil', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcReinforcementBarProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementBarProperties', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcReinforcementDefinitionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementDefinitionProperties', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcReinforcingBar(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBar', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcReinforcingBarType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBarType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcReinforcingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcReinforcingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcReinforcingMesh(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMesh', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcReinforcingMeshType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMeshType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAggregates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAggregates', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssigns(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssigns', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssignsToActor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToActor', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssignsToControl(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToControl', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssignsToGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroup', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssignsToGroupByFactor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroupByFactor', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssignsToProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProcess', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssignsToProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProduct', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssignsToResource(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToResource', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssociates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociates', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssociatesApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesApproval', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssociatesClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesClassification', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssociatesConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesConstraint', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssociatesDocument(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesDocument', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssociatesLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesLibrary', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssociatesMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesMaterial', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelAssociatesProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelConnects(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnects', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelConnectsElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsElements', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelConnectsPathElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPathElements', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelConnectsPortToElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPortToElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelConnectsPorts(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPorts', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelConnectsStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralActivity', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelConnectsStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralMember', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelConnectsWithEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithEccentricity', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelConnectsWithRealizingElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithRealizingElements', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelContainedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelContainedInSpatialStructure', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelCoversBldgElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversBldgElements', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelCoversSpaces(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversSpaces', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelDeclares(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDeclares', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelDecomposes(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDecomposes', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelDefines(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefines', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelDefinesByObject(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByObject', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelDefinesByProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByProperties', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelDefinesByTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByTemplate', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelDefinesByType(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelFillsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFillsElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelFlowControlElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFlowControlElements', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelInterferesElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelInterferesElements', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelNests(*args, **kwargs): return ifcopenshell.create_entity('IfcRelNests', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelPositions(*args, **kwargs): return ifcopenshell.create_entity('IfcRelPositions', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelProjectsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelProjectsElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelReferencedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelReferencedInSpatialStructure', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelSequence(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSequence', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelServicesBuildings(*args, **kwargs): return ifcopenshell.create_entity('IfcRelServicesBuildings', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelSpaceBoundary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelSpaceBoundary1stLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary1stLevel', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelSpaceBoundary2ndLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary2ndLevel', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelVoidsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelVoidsElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcRelationship', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcReparametrisedCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcReparametrisedCompositeCurveSegment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentation', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationContext', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationItem', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRepresentationMap(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationMap', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcResource(*args, **kwargs): return ifcopenshell.create_entity('IfcResource', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcResourceApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceApprovalRelationship', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcResourceConstraintRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceConstraintRelationship', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcResourceLevelRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceLevelRelationship', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcResourceTime(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceTime', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRevolvedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRevolvedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolidTapered', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRightCircularCone(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCone', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRightCircularCylinder(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCylinder', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRoad(*args, **kwargs): return ifcopenshell.create_entity('IfcRoad', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRoof(*args, **kwargs): return ifcopenshell.create_entity('IfcRoof', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRoofType(*args, **kwargs): return ifcopenshell.create_entity('IfcRoofType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRoot(*args, **kwargs): return ifcopenshell.create_entity('IfcRoot', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcRoundedRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRoundedRectangleProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSIUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcSIUnit', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSanitaryTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminal', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSanitaryTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminalType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSchedulingTime(*args, **kwargs): return ifcopenshell.create_entity('IfcSchedulingTime', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSeamCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSeamCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSecondOrderPolynomialSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSecondOrderPolynomialSpiral', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSectionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionProperties', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSectionReinforcementProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionReinforcementProperties', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSectionedSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSectionedSolidHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolidHorizontal', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSectionedSpine(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSpine', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSectionedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSurface', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcSegment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSegmentedReferenceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSegmentedReferenceCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSensor(*args, **kwargs): return ifcopenshell.create_entity('IfcSensor', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSensorType(*args, **kwargs): return ifcopenshell.create_entity('IfcSensorType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcShadingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDevice', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcShadingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDeviceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcShapeAspect(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeAspect', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcShapeModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeModel', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcShapeRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeRepresentation', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcShellBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShellBasedSurfaceModel', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSign(*args, **kwargs): return ifcopenshell.create_entity('IfcSign', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSignType(*args, **kwargs): return ifcopenshell.create_entity('IfcSignType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSignal(*args, **kwargs): return ifcopenshell.create_entity('IfcSignal', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSignalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSignalType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSimpleProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcSimpleProperty', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSimplePropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcSimplePropertyTemplate', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSine(*args, **kwargs): return ifcopenshell.create_entity('IfcSine', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSite(*args, **kwargs): return ifcopenshell.create_entity('IfcSite', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSlab(*args, **kwargs): return ifcopenshell.create_entity('IfcSlab', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSlabElementedCase(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabElementedCase', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSlabStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabStandardCase', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSlabType(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSlippageConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcSlippageConnectionCondition', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSolarDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDevice', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSolarDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDeviceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSolidModel(*args, **kwargs): return ifcopenshell.create_entity('IfcSolidModel', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSolidStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcSolidStratum', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcSpace', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSpaceHeater(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeater', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSpaceHeaterType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeaterType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSpaceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSpatialElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSpatialStructureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSpatialZone(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZone', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSpatialZoneType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZoneType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSphere(*args, **kwargs): return ifcopenshell.create_entity('IfcSphere', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSphericalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSphericalSurface', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSpiral', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStackTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminal', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStackTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminalType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStair(*args, **kwargs): return ifcopenshell.create_entity('IfcStair', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStairFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlight', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStairFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlightType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStairType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAction', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralActivity', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralAnalysisModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAnalysisModel', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnection', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnectionCondition', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralCurveAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveAction', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralCurveConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveConnection', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralCurveMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMember', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralCurveMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMemberVarying', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralCurveReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveReaction', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralItem', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralLinearAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLinearAction', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralLoad(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoad', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralLoadCase(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadCase', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralLoadConfiguration(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadConfiguration', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralLoadGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadGroup', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralLoadLinearForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadLinearForce', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralLoadOrResult(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadOrResult', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralLoadPlanarForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadPlanarForce', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacement(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacementDistortion(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacementDistortion', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralLoadSingleForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForce', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralLoadSingleForceWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForceWarping', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralLoadStatic(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadStatic', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralLoadTemperature(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadTemperature', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralMember', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralPlanarAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPlanarAction', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralPointAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointAction', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralPointConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointConnection', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralPointReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointReaction', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralReaction', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralResultGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralResultGroup', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralSurfaceAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceAction', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralSurfaceConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceConnection', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralSurfaceMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMember', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralSurfaceMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMemberVarying', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStructuralSurfaceReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceReaction', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStyleModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStyleModel', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStyledItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledItem', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcStyledRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledRepresentation', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSubContractResource(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResource', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSubContractResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResourceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSubedge(*args, **kwargs): return ifcopenshell.create_entity('IfcSubedge', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSurface', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSurfaceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSurfaceCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurveSweptAreaSolid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSurfaceFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceFeature', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSurfaceOfLinearExtrusion(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfLinearExtrusion', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSurfaceOfRevolution(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfRevolution', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSurfaceReinforcementArea(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceReinforcementArea', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyle', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSurfaceStyleLighting(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleLighting', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSurfaceStyleRefraction(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRefraction', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSurfaceStyleRendering(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRendering', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSurfaceStyleShading(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleShading', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSurfaceStyleWithTextures(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleWithTextures', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSurfaceTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceTexture', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptAreaSolid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSweptDiskSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolid', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSweptDiskSolidPolygonal(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolidPolygonal', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSweptSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptSurface', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSwitchingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDevice', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSwitchingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDeviceType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcSystem', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSystemFurnitureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcSystemFurnitureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTShapeProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTable(*args, **kwargs): return ifcopenshell.create_entity('IfcTable', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTableColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcTableColumn', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTableRow(*args, **kwargs): return ifcopenshell.create_entity('IfcTableRow', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTank(*args, **kwargs): return ifcopenshell.create_entity('IfcTank', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTankType(*args, **kwargs): return ifcopenshell.create_entity('IfcTankType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTask(*args, **kwargs): return ifcopenshell.create_entity('IfcTask', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTaskTime(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTime', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTaskTimeRecurring(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTimeRecurring', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTaskType(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTelecomAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcTelecomAddress', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTendon(*args, **kwargs): return ifcopenshell.create_entity('IfcTendon', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTendonAnchor(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchor', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTendonAnchorType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchorType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTendonConduit(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduit', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTendonConduitType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduitType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTendonType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTessellatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedFaceSet', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTessellatedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedItem', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTextLiteral(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteral', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTextLiteralWithExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteralWithExtent', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTextStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyle', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTextStyleFontModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleFontModel', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTextStyleForDefinedFont(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleForDefinedFont', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTextStyleTextModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleTextModel', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTextureCoordinate(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinate', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTextureCoordinateGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateGenerator', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureMap', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTextureVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertex', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTextureVertexList(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertexList', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcThirdOrderPolynomialSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcThirdOrderPolynomialSpiral', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTimePeriod(*args, **kwargs): return ifcopenshell.create_entity('IfcTimePeriod', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeries', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeriesValue', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTopologicalRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologicalRepresentationItem', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTopologyRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologyRepresentation', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcToroidalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcToroidalSurface', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTrackElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTrackElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTrackElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTrackElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTransformer(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformer', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTransformerType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformerType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTransportElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTransportElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTrapeziumProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTrapeziumProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTriangulatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedFaceSet', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTriangulatedIrregularNetwork(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedIrregularNetwork', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTrimmedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcTrimmedCurve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTubeBundle(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundle', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTubeBundleType(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundleType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTypeObject(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeObject', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTypeProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProcess', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTypeProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProduct', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcTypeResource(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeResource', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcUShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcUShapeProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcUnitAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitAssignment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcUnitaryControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcUnitaryControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElementType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcUnitaryEquipment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipment', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcUnitaryEquipmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipmentType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcValve(*args, **kwargs): return ifcopenshell.create_entity('IfcValve', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcValveType(*args, **kwargs): return ifcopenshell.create_entity('IfcValveType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcVector(*args, **kwargs): return ifcopenshell.create_entity('IfcVector', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcVertex', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcVertexLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexLoop', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcVertexPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexPoint', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcVibrationDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamper', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcVibrationDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamperType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcVibrationIsolator(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolator', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcVibrationIsolatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolatorType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcVienneseBend(*args, **kwargs): return ifcopenshell.create_entity('IfcVienneseBend', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcVirtualElement(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualElement', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcVirtualGridIntersection(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualGridIntersection', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcVoidStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcVoidStratum', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcVoidingFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcVoidingFeature', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWall(*args, **kwargs): return ifcopenshell.create_entity('IfcWall', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWallElementedCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallElementedCase', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWallStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallStandardCase', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcWallType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWasteTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminal', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWasteTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminalType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWaterStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcWaterStratum', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWindow(*args, **kwargs): return ifcopenshell.create_entity('IfcWindow', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWindowLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowLiningProperties', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWindowPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowPanelProperties', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWindowStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowStandardCase', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWindowStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowStyle', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWindowType(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowType', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWorkCalendar(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkCalendar', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWorkControl(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkControl', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWorkPlan(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkPlan', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWorkSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkSchedule', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcWorkTime(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkTime', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcZShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcZShapeProfileDef', 'IFC4X3_RC3', *args, **kwargs) + + +def IfcZone(*args, **kwargs): return ifcopenshell.create_entity('IfcZone', 'IFC4X3_RC3', *args, **kwargs) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcBoxAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcBoxAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['top-left','top-middle','top-right','middle-left','center','middle-right','bottom-left','bottom-middle','bottom-right'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCardinalPointReference_GreaterThanZero: + SCOPE = "type" + TYPE_NAME = "IfcCardinalPointReference" + RULE_NAME = "GreaterThanZero" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCompoundPlaneAngleMeasure_MinutesInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MinutesInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[2 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_SecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "SecondsInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[3 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_MicrosecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MicrosecondsInRange" + + @staticmethod + def __call__(self): + + + assert (sizeof(self) == 3) or ((abs(self[4 - 1])) < 1000000) + + + + +class IfcCompoundPlaneAngleMeasure_ConsistentSign: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "ConsistentSign" + + @staticmethod + def __call__(self): + + + assert (((self[1 - 1]) >= 0) and ((self[2 - 1]) >= 0) and ((self[3 - 1]) >= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) >= 0))) or (((self[1 - 1]) <= 0) and ((self[2 - 1]) <= 0) and ((self[3 - 1]) <= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) <= 0))) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDayInMonthNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInMonthNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 31 + + + + + +class IfcDayInWeekNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInWeekNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 7 + + + + + + + + + + + + + + + + + +class IfcDimensionCount_WR1: + SCOPE = "type" + TYPE_NAME = "IfcDimensionCount" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0 < self <= 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFontStyle_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontStyle" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','italic','oblique'] + + + + + +class IfcFontVariant_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontVariant" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps'] + + + + + +class IfcFontWeight_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontWeight" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps','100','200','300','400','500','600','700','800','900'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcHeatingValueMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcHeatingValueMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMonthInYearNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcMonthInYearNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 12 + + + + + + + + + + + + + + +class IfcNonNegativeLengthMeasure_NotNegative: + SCOPE = "type" + TYPE_NAME = "IfcNonNegativeLengthMeasure" + RULE_NAME = "NotNegative" + + @staticmethod + def __call__(self): + + + assert self >= 0. + + + + + +class IfcNormalisedRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcNormalisedRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPHMeasure_WR21: + SCOPE = "type" + TYPE_NAME = "IfcPHMeasure" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 14.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPositiveInteger_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveInteger" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + +class IfcPositiveLengthMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveLengthMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositivePlaneAngleMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositivePlaneAngleMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositiveRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcSpecularRoughness_WR1: + SCOPE = "type" + TYPE_NAME = "IfcSpecularRoughness" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTextAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['left','right','center','justify'] + + + + + +class IfcTextDecoration_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextDecoration" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['none','underline','overline','line-through','blink'] + + + + + + + + + + + + + + +class IfcTextTransformation_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextTransformation" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['capitalize','uppercase','lowercase','none'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcActorRole_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcActorRole" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + role = self.Role + + assert (role != IfcRoleEnum.USERDEFINED) or ((role == IfcRoleEnum.USERDEFINED) and exists(self.UserDefinedRole)) + + + + + +class IfcActuator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcActuator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcactuatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcActuatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + purpose = self.Purpose + + assert (not exists(purpose)) or ((purpose != IfcAddressTypeEnum.USERDEFINED) or ((purpose == IfcAddressTypeEnum.USERDEFINED) and exists(self.UserDefinedPurpose))) + + + + + +class IfcAdvancedBrep_HasAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrep" + RULE_NAME = "HasAdvancedFaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([afs for afs in self.Outer.CfsFaces if not 'ifc4x3_rc3.ifcadvancedface' in typeof(afs)])) == 0 + + + + + +class IfcAdvancedBrepWithVoids_VoidsHaveAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrepWithVoids" + RULE_NAME = "VoidsHaveAdvancedFaces" + + @staticmethod + def __call__(self): + voids = self.Voids + + assert (sizeof([vsh for vsh in voids if (sizeof([afs for afs in vsh.CfsFaces if not 'ifc4x3_rc3.ifcadvancedface' in typeof(afs)])) == 0])) == 0 + + + + + +class IfcAdvancedFace_ApplicableSurface: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableSurface" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc3.ifcelementarysurface','ifc4x3_rc3.ifcsweptsurface','ifc4x3_rc3.ifcbsplinesurface'] * typeof(self.FaceSurface))) == 1 + + + + +class IfcAdvancedFace_RequiresEdgeCurve: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "RequiresEdgeCurve" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x3_rc3.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not 'ifc4x3_rc3.ifcedgecurve' in typeof(oe.EdgeElement)])) == 0])) == 0 + + + + +class IfcAdvancedFace_ApplicableEdgeCurves: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableEdgeCurves" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x3_rc3.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not (sizeof(['ifc4x3_rc3.ifcline','ifc4x3_rc3.ifcconic','ifc4x3_rc3.ifcpolyline','ifc4x3_rc3.ifcbsplinecurve'] * typeof(oe.EdgeElement.EdgeGeometry))) == 1])) == 0])) == 0 + + + + + +class IfcAirTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcairterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminalBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcairterminalboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirToAirHeatRecovery_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirToAirHeatRecovery_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcairtoairheatrecoverytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirToAirHeatRecoveryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecoveryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAlarm_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAlarm_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcalarmtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAlarmType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarmType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcApproval_HasIdentifierOrName: + SCOPE = "entity" + TYPE_NAME = "IfcApproval" + RULE_NAME = "HasIdentifierOrName" + + @staticmethod + def __call__(self): + identifier = self.Identifier + name = self.Name + + assert exists(identifier) or exists(name) + + + + + + + + +class IfcArbitraryClosedProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert outercurve.Dim == 2 + + + + +class IfcArbitraryClosedProfileDef_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x3_rc3.ifcline' in typeof(outercurve) + + + + +class IfcArbitraryClosedProfileDef_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x3_rc3.ifcoffsetcurve2d' in typeof(outercurve) + + + + + +class IfcArbitraryOpenProfileDef_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_rc3.ifccenterlineprofiledef' in typeof(self)) or (self.ProfileType == IfcProfileTypeEnum.CURVE) + + + + +class IfcArbitraryOpenProfileDef_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + curve = self.Curve + + assert curve.Dim == 2 + + + + + +class IfcArbitraryProfileDefWithVoids_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == area + + + + +class IfcArbitraryProfileDefWithVoids_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if temp.Dim != 2])) == 0 + + + + +class IfcArbitraryProfileDefWithVoids_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if 'ifc4x3_rc3.ifcline' in typeof(temp)])) == 0 + + + + + + + + +class IfcAsymmetricIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + bottomflangethickness = self.BottomFlangeThickness + topflangethickness = self.TopFlangeThickness + + assert (not exists(topflangethickness)) or ((bottomflangethickness + topflangethickness) < overalldepth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + + assert (webthickness < bottomflangewidth) and (webthickness < topflangewidth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidBottomFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidBottomFilletRadius" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + bottomflangefilletradius = self.BottomFlangeFilletRadius + + assert (not exists(bottomflangefilletradius)) or (bottomflangefilletradius <= ((bottomflangewidth - webthickness) / 2.)) + + + + +class IfcAsymmetricIShapeProfileDef_ValidTopFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidTopFilletRadius" + + @staticmethod + def __call__(self): + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + topflangefilletradius = self.TopFlangeFilletRadius + + assert (not exists(topflangefilletradius)) or (topflangefilletradius <= ((topflangewidth - webthickness) / 2.)) + + + + + +class IfcAudioVisualAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAudioVisualAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcaudiovisualappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAudioVisualApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAxis1Placement_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis1Placement_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis1Placement_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc3.ifccartesianpoint' in typeof(self.Location) + + + + +def calc_IfcAxis1Placement_Z(self): + axis = self.Axis + return \ + nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + + + + +class IfcAxis2Placement2D_RefDirIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "RefDirIs2D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 2) + + + + +class IfcAxis2Placement2D_LocationIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIs2D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 2 + + + + +class IfcAxis2Placement2D_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc3.ifccartesianpoint' in typeof(self.Location) + + + + +def calc_IfcAxis2Placement2D_P(self): + refdirection = self.RefDirection + return \ + IfcBuild2Axes(refdirection) + + + + +class IfcAxis2Placement3D_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis2Placement3D_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis2Placement3D_RefDirIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "RefDirIs3D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 3) + + + + +class IfcAxis2Placement3D_AxisToRefDirPosition: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisToRefDirPosition" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + +class IfcAxis2Placement3D_AxisAndRefDirProvision: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisAndRefDirProvision" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert not exists(axis) ^ exists(refdirection) + + + + +class IfcAxis2Placement3D_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc3.ifccartesianpoint' in typeof(self.Location) + + + + +def calc_IfcAxis2Placement3D_P(self): + axis = self.Axis + refdirection = self.RefDirection + return \ + IfcBuildAxes(axis,refdirection) + + + + +class IfcAxis2PlacementLinear_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2PlacementLinear" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc3.ifcpointbydistanceexpression' in typeof(self.Location) + + + + +class IfcAxis2PlacementLinear_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2PlacementLinear" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + + +class IfcBSplineCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + controlpointslist = self.ControlPointsList + + assert (sizeof([temp for temp in controlpointslist if temp.Dim != (controlpointslist[1 - 1].Dim)])) == 0 + + + + +def calc_IfcBSplineCurve_UpperIndexOnControlPoints(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineCurve_ControlPoints(self): + controlpointslist = self.ControlPointsList + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + return \ + IfcListToArray(controlpointslist,0,upperindexoncontrolpoints) + + + + +class IfcBSplineCurveWithKnots_ConsistentBSpline: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "ConsistentBSpline" + + @staticmethod + def __call__(self): + degree = self.Degree + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + knotmultiplicities = self.KnotMultiplicities + knots = self.Knots + upperindexonknots = self.UpperIndexOnKnots + + assert IfcConstraintsParamBSpline(degree,upperindexonknots,upperindexoncontrolpoints,knotmultiplicities,knots) + + + + +class IfcBSplineCurveWithKnots_CorrespondingKnotLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "CorrespondingKnotLists" + + @staticmethod + def __call__(self): + knotmultiplicities = self.KnotMultiplicities + upperindexonknots = self.UpperIndexOnKnots + + assert sizeof(knotmultiplicities) == upperindexonknots + + + + +def calc_IfcBSplineCurveWithKnots_UpperIndexOnKnots(self): + knots = self.Knots + return \ + sizeof(knots) + + + + +def calc_IfcBSplineSurface_UUpper(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineSurface_VUpper(self): + controlpointslist = self.ControlPointsList + return \ + (sizeof(controlpointslist[1 - 1])) - 1 + + + +def calc_IfcBSplineSurface_ControlPoints(self): + controlpointslist = self.ControlPointsList + uupper = self.UUpper + vupper = self.VUpper + return \ + IfcMakeArrayOfArray(controlpointslist,0,uupper,0,vupper) + + + + +class IfcBSplineSurfaceWithKnots_UDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "UDirectionConstraints" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + uknots = self.UKnots + knotuupper = self.KnotUUpper + + assert IfcConstraintsParamBSpline(self.UDegree,knotuupper,self.UUpper,umultiplicities,uknots) + + + + +class IfcBSplineSurfaceWithKnots_VDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "VDirectionConstraints" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + vknots = self.VKnots + knotvupper = self.KnotVUpper + + assert IfcConstraintsParamBSpline(self.VDegree,knotvupper,self.VUpper,vmultiplicities,vknots) + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingULists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingULists" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + knotuupper = self.KnotUUpper + + assert sizeof(umultiplicities) == knotuupper + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingVLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingVLists" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + knotvupper = self.KnotVUpper + + assert sizeof(vmultiplicities) == knotvupper + + + + +def calc_IfcBSplineSurfaceWithKnots_KnotVUpper(self): + vknots = self.VKnots + return \ + sizeof(vknots) + + + +def calc_IfcBSplineSurfaceWithKnots_KnotUUpper(self): + uknots = self.UKnots + return \ + sizeof(uknots) + + + + +class IfcBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBeamStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcBeamStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc3.ifcrelassociates.relatedobjects') if ('ifc4x3_rc3.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc3.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBearing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBearing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcbearingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBearingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBlobTexture_SupportedRasterFormat: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "SupportedRasterFormat" + + @staticmethod + def __call__(self): + + + assert self.RasterFormat in ['bmp','jpg','gif','png'] + + + + +class IfcBlobTexture_RasterCodeByteStream: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "RasterCodeByteStream" + + @staticmethod + def __call__(self): + rastercode = self.RasterCode + + assert (blength(rastercode) % 8) == 0 + + + + + + + + +class IfcBoiler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBoiler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcboilertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBoilerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoilerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBooleanClippingResult_FirstOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "FirstOperandType" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert ('ifc4x3_rc3.ifcsweptareasolid' in typeof(firstoperand)) or ('ifc4x3_rc3.ifcsweptdiscsolid' in typeof(firstoperand)) or ('ifc4x3_rc3.ifcbooleanclippingresult' in typeof(firstoperand)) + + + + +class IfcBooleanClippingResult_SecondOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "SecondOperandType" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert 'ifc4x3_rc3.ifchalfspacesolid' in typeof(secondoperand) + + + + +class IfcBooleanClippingResult_OperatorType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "OperatorType" + + @staticmethod + def __call__(self): + operator = self.Operator + + assert operator == difference + + + + + +class IfcBooleanResult_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + secondoperand = self.SecondOperand + + assert firstoperand.Dim == secondoperand.Dim + + + + +class IfcBooleanResult_FirstOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "FirstOperandClosed" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert (not 'ifc4x3_rc3.ifctessellatedfaceset' in typeof(firstoperand)) or (exists(firstoperand.Closed) and firstoperand.Closed) + + + + +class IfcBooleanResult_SecondOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SecondOperandClosed" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert (not 'ifc4x3_rc3.ifctessellatedfaceset' in typeof(secondoperand)) or (exists(secondoperand.Closed) and secondoperand.Closed) + + + + +def calc_IfcBooleanResult_Dim(self): + firstoperand = self.FirstOperand + return \ + firstoperand.Dim + + + + + + + + + + +class IfcBoundaryCurve_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBoundaryCurve" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + + + assert self.ClosedCurve + + + + + + + + + + + + + + + + + + + + + + + +def calc_IfcBoundingBox_Dim(self): + + return \ + 3 + + + + +class IfcBoxedHalfSpace_UnboundedSurface: + SCOPE = "entity" + TYPE_NAME = "IfcBoxedHalfSpace" + RULE_NAME = "UnboundedSurface" + + @staticmethod + def __call__(self): + + + assert not 'ifc4x3_rc3.ifccurveboundedplane' in typeof(self.BaseSurface) + + + + + +class IfcBridge_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBridge" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBridgeTypeEnum.USERDEFINED) or ((predefinedtype == IfcBridgeTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcBuildingElementPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementPart_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcbuildingelementparttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementPartType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPartType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBuildingElementProxy_HasObjectName: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "HasObjectName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcBuildingElementProxy_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementProxy_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcbuildingelementproxytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementProxyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcBuiltElement_MaxOneMaterialAssociation: + SCOPE = "entity" + TYPE_NAME = "IfcBuiltElement" + RULE_NAME = "MaxOneMaterialAssociation" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.HasAssociations if 'ifc4x3_rc3.ifcrelassociatesmaterial' in typeof(temp)])) <= 1 + + + + + + + + +class IfcBuiltSystem_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuiltSystem" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuiltSystemTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuiltSystemTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcBurner_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBurner_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcburnertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBurnerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurnerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCShapeProfileDef_ValidGirth: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidGirth" + + @staticmethod + def __call__(self): + depth = self.Depth + girth = self.Girth + + assert girth < (depth / 2.) + + + + +class IfcCShapeProfileDef_ValidInternalFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidInternalFilletRadius" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + internalfilletradius = self.InternalFilletRadius + + assert (not exists(internalfilletradius)) or ((internalfilletradius <= ((width / 2.) - wallthickness)) and (internalfilletradius <= ((depth / 2.) - wallthickness))) + + + + +class IfcCShapeProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + + assert (wallthickness < (width / 2.)) and (wallthickness < (depth / 2.)) + + + + + +class IfcCableCarrierFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccablecarrierfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableCarrierSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccablecarriersegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccablefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccablesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCaissonFoundation_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCaissonFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccaissonfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCaissonFoundationType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundationType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCartesianPoint_CP2Dor3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianPoint" + RULE_NAME = "CP2Dor3D" + + @staticmethod + def __call__(self): + coordinates = self.Coordinates + + assert hiindex(coordinates) >= 2 + + + + +def calc_IfcCartesianPoint_Dim(self): + coordinates = self.Coordinates + return \ + hiindex(coordinates) + + + + +def calc_IfcCartesianPointList_Dim(self): + + return \ + IfcPointListDim(self) + + + + + + + + + + +class IfcCartesianTransformationOperator_ScaleGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator" + RULE_NAME = "ScaleGreaterZero" + + @staticmethod + def __call__(self): + scl = self.Scl + + assert scl > 0.0 + + + + +def calc_IfcCartesianTransformationOperator_Scl(self): + scale = self.Scale + return \ + nvl(scale,1.0) + + + +def calc_IfcCartesianTransformationOperator_Dim(self): + localorigin = self.LocalOrigin + return \ + localorigin.Dim + + + + +class IfcCartesianTransformationOperator2D_DimEqual2: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "DimEqual2" + + @staticmethod + def __call__(self): + + + assert self.Dim == 2 + + + + +class IfcCartesianTransformationOperator2D_Axis1Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis1Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 2) + + + + +class IfcCartesianTransformationOperator2D_Axis2Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis2Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 2) + + + + +def calc_IfcCartesianTransformationOperator2D_U(self): + + return \ + IfcBaseAxis(2,self.Axis1,self.Axis2,None) + + + + +class IfcCartesianTransformationOperator2DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator2DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + + +class IfcCartesianTransformationOperator3D_DimIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "DimIs3D" + + @staticmethod + def __call__(self): + + + assert self.Dim == 3 + + + + +class IfcCartesianTransformationOperator3D_Axis1Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis1Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis2Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis2Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis3Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis3Is3D" + + @staticmethod + def __call__(self): + axis3 = self.Axis3 + + assert (not exists(axis3)) or (axis3.Dim == 3) + + + + +def calc_IfcCartesianTransformationOperator3D_U(self): + axis3 = self.Axis3 + return \ + IfcBaseAxis(3,self.Axis1,self.Axis2,axis3) + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale3GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale3GreaterZero" + + @staticmethod + def __call__(self): + scl3 = self.Scl3 + + assert scl3 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl3(self): + scale3 = self.Scale3 + return \ + nvl(scale3,self.Scl) + + + + + + + +class IfcChiller_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChiller_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcchillertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChillerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChillerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcChimney_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChimney_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcchimneytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChimneyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimneyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcCircleHollowProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCircleHollowProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert wallthickness < self.Radius + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoil_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccoiltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoilType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoilType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcColumn_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcColumn_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccolumntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcColumnStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcColumnStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc3.ifcrelassociates.relatedobjects') if ('ifc4x3_rc3.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc3.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcColumnType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumnType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcComplexProperty_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert (sizeof([temp for temp in hasproperties if self == temp])) == 0 + + + + +class IfcComplexProperty_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + +class IfcComplexPropertyTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + +class IfcComplexPropertyTemplate_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert (sizeof([temp for temp in haspropertytemplates if self == temp])) == 0 + + + + + +class IfcCompositeCurve_CurveContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "CurveContinuous" + + @staticmethod + def __call__(self): + segments = self.Segments + closedcurve = self.ClosedCurve + + assert ((not closedcurve) and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 1)) or (closedcurve and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 0)) + + + + +class IfcCompositeCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (sizeof([temp for temp in segments if temp.Dim != (segments[1 - 1].Dim)])) == 0 + + + + +def calc_IfcCompositeCurve_NSegments(self): + segments = self.Segments + return \ + sizeof(segments) + + + +def calc_IfcCompositeCurve_ClosedCurve(self): + segments = self.Segments + nsegments = self.NSegments + return \ + (segments[nsegments - 1].Transition) != discontinuous + + + + +class IfcCompositeCurveOnSurface_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveOnSurface" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + + assert sizeof(basissurface) > 0 + + + + +def calc_IfcCompositeCurveOnSurface_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + +class IfcCompositeCurveSegment_ParentIsBoundedCurve: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveSegment" + RULE_NAME = "ParentIsBoundedCurve" + + @staticmethod + def __call__(self): + parentcurve = self.ParentCurve + + assert 'ifc4x3_rc3.ifcboundedcurve' in typeof(parentcurve) + + + + +def calc_IfcCompositeCurveSegment_Dim(self): + parentcurve = self.ParentCurve + return \ + parentcurve.Dim + + + + +class IfcCompositeProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if temp.ProfileType != (profiles[1 - 1].ProfileType)])) == 0 + + + + +class IfcCompositeProfileDef_NoRecursion: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "NoRecursion" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if 'ifc4x3_rc3.ifccompositeprofiledef' in typeof(temp)])) == 0 + + + + + +class IfcCompressor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCompressor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccompressortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCompressorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCondenser_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCondenser_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccondensertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCondenserType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenserType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcConstraint_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcConstraint" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + constraintgrade = self.ConstraintGrade + + assert (constraintgrade != IfcConstraintEnum.USERDEFINED) or ((constraintgrade == IfcConstraintEnum.USERDEFINED) and exists(self.UserDefinedGrade)) + + + + + +class IfcConstructionEquipmentResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionEquipmentResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionMaterialResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionMaterialResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionProductResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionProductResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + + + + + + + + + + + + + +class IfcController_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcController_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccontrollertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcControllerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcControllerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcConveyorSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConveyorSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcConveyorSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcConveyorSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcconveyorsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcConveyorSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConveyorSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcConveyorSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCooledBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCooledBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccooledbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCooledBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCoolingTower_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoolingTower_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccoolingtowertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoolingTowerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTowerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + +class IfcCourse_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCourse" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCourseTypeEnum.USERDEFINED) or ((predefinedtype == IfcCourseTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCourse_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCourse" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccoursetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCourseType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCourseType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCourseTypeEnum.USERDEFINED) or ((predefinedtype == IfcCourseTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCovering_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCovering_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccoveringtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoveringType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoveringType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCrewResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcCrewResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +def calc_IfcCsgPrimitive3D_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcCurtainWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCurtainWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifccurtainwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCurtainWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcCurve_Dim(self): + + return \ + IfcCurveDim(self) + + + + + + + + + + +def calc_IfcCurveSegment_Dim(self): + parentcurve = self.ParentCurve + return \ + parentcurve.Dim + + + + +class IfcCurveStyle_MeasureOfWidth: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "MeasureOfWidth" + + @staticmethod + def __call__(self): + curvewidth = self.CurveWidth + + assert (not exists(curvewidth)) or ('ifc4x3_rc3.ifcpositivelengthmeasure' in typeof(curvewidth)) or (('ifc4x3_rc3.ifcdescriptivemeasure' in typeof(curvewidth)) and (curvewidth == 'bylayer')) + + + + +class IfcCurveStyle_IdentifiableCurveStyle: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "IdentifiableCurveStyle" + + @staticmethod + def __call__(self): + curvefont = self.CurveFont + curvewidth = self.CurveWidth + curvecolour = self.CurveColour + + assert exists(curvefont) or exists(curvewidth) or exists(curvecolour) + + + + + + + + + + + +class IfcCurveStyleFontPattern_VisibleLengthGreaterEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyleFontPattern" + RULE_NAME = "VisibleLengthGreaterEqualZero" + + @staticmethod + def __call__(self): + visiblesegmentlength = self.VisibleSegmentLength + + assert visiblesegmentlength >= 0. + + + + + + + + +class IfcDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDeepFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDeepFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcdeepfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + + + + +class IfcDerivedProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + parentprofile = self.ParentProfile + + assert self.ProfileType == parentprofile.ProfileType + + + + + +class IfcDerivedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof(elements) > 1) or ((sizeof(elements) == 1) and ((elements[1 - 1].Exponent) != 1)) + + + + +class IfcDerivedUnit_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + unittype = self.UnitType + + assert (unittype != IfcDerivedUnitEnum.USERDEFINED) or ((unittype == IfcDerivedUnitEnum.USERDEFINED) and exists(self.UserDefinedType)) + + + + +def calc_IfcDerivedUnit_Dimensions(self): + elements = self.Elements + return \ + IfcDeriveDimensionalExponents(elements) + + + + + + + + + + +class IfcDirection_MagnitudeGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcDirection" + RULE_NAME = "MagnitudeGreaterZero" + + @staticmethod + def __call__(self): + directionratios = self.DirectionRatios + + assert (sizeof([tmp for tmp in directionratios if tmp != 0.0])) > 0 + + + + +def calc_IfcDirection_Dim(self): + directionratios = self.DirectionRatios + return \ + hiindex(directionratios) + + + + +class IfcDirectrixCurveSweptAreaSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcDirectrixCurveSweptAreaSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x3_rc3.ifcconic','ifc4x3_rc3.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + + + + + + + +class IfcDiscreteAccessory_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDiscreteAccessory_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcdiscreteaccessorytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDiscreteAccessoryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessoryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDistributionChamberElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionChamberElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcdistributionchamberelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionChamberElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDistributionSystem_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionSystem" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionSystemEnum.USERDEFINED) or ((predefinedtype == IfcDistributionSystemEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcDocumentReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDocumentReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + name = self.Name + referenceddocument = self.ReferencedDocument + + assert exists(name) ^ exists(referenceddocument) + + + + + +class IfcDoor_CorrectStyleAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectStyleAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcdoortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + +class IfcDoor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDoorTypeEnum.USERDEFINED) or ((predefinedtype == IfcDoorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDoor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcdoortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDoorLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcDoorLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + thresholddepth = self.ThresholdDepth + thresholdthickness = self.ThresholdThickness + + assert not exists(thresholddepth) and (not exists(thresholdthickness)) + + + + +class IfcDoorLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + transomthickness = self.TransomThickness + transomoffset = self.TransomOffset + + assert (exists(transomoffset) and exists(transomthickness)) ^ ((not exists(transomoffset)) and (not exists(transomthickness))) + + + + +class IfcDoorLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + casingthickness = self.CasingThickness + casingdepth = self.CasingDepth + + assert (exists(casingdepth) and exists(casingthickness)) ^ ((not exists(casingdepth)) and (not exists(casingthickness))) + + + + +class IfcDoorLiningProperties_WR35: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR35" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc3.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc3.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcDoorPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc3.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc3.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + + + + + + + +class IfcDoorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDoorTypeEnum.USERDEFINED) or ((predefinedtype == IfcDoorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDraughtingPreDefinedColour_PreDefinedColourNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedColour" + RULE_NAME = "PreDefinedColourNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['black','red','green','blue','yellow','magenta','cyan','white','bylayer'] + + + + + +class IfcDraughtingPreDefinedCurveFont_PreDefinedCurveFontNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedCurveFont" + RULE_NAME = "PreDefinedCurveFontNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['continuous','chain','chaindoubledash','dashed','dotted','bylayer'] + + + + + +class IfcDuctFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcductfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcductsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSilencer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSilencer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcductsilencertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSilencerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEarthworksCut_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEarthworksCut" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEarthworksCutTypeEnum.USERDEFINED) or ((predefinedtype == IfcEarthworksCutTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcEarthworksFill_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEarthworksFill" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEarthworksFillTypeEnum.USERDEFINED) or ((predefinedtype == IfcEarthworksFillTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcEdgeLoop_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + edgelist = self.EdgeList + ne = self.Ne + + assert (edgelist[1 - 1].EdgeStart) == (edgelist[ne - 1].EdgeEnd) + + + + +class IfcEdgeLoop_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcLoopHeadToTail(self) + + + + +def calc_IfcEdgeLoop_Ne(self): + edgelist = self.EdgeList + return \ + sizeof(edgelist) + + + + +class IfcElectricAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcelectricappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcelectricdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowStorageDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowStorageDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcelectricflowstoragedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowStorageDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowTreatmentDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowTreatmentDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcelectricflowtreatmentdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowTreatmentDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricGenerator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricGenerator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcelectricgeneratortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricGeneratorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGeneratorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricMotor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricMotor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcelectricmotortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricMotorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricTimeControl_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricTimeControl_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcelectrictimecontroltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricTimeControlType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControlType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcElementAssembly_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElementAssembly_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcelementassemblytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElementAssemblyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssemblyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcElementQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcElementQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + quantities = self.Quantities + + assert IfcUniqueQuantityNames(quantities) + + + + + + + + + + + + + + + + + + + + + + + +class IfcEngine_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEngine_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcenginetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEngineType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngineType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporativeCooler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporativeCooler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcevaporativecoolertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporativeCoolerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCoolerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcevaporatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvent_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvent_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (not exists(eventtriggertype)) or (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + +class IfcEventType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + +class IfcEventType_CorrectEventTriggerType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectEventTriggerType" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + + + + +class IfcExternalReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcExternalReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + location = self.Location + identification = self.Identification + name = self.Name + + assert exists(identification) or exists(location) or exists(name) + + + + + + + + + + + + + + + + + + + + + + + +class IfcExtrudedAreaSolid_ValidExtrusionDirection: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolid" + RULE_NAME = "ValidExtrusionDirection" + + @staticmethod + def __call__(self): + + + assert IfcDotProduct(IfcDirection(DirectionRatios=[0.0,0.0,1.0]),self.ExtrudedDirection) != 0.0 + + + + + +class IfcExtrudedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + +class IfcFace_HasOuterBound: + SCOPE = "entity" + TYPE_NAME = "IfcFace" + RULE_NAME = "HasOuterBound" + + @staticmethod + def __call__(self): + bounds = self.Bounds + + assert (sizeof([temp for temp in bounds if 'ifc4x3_rc3.ifcfaceouterbound' in typeof(temp)])) <= 1 + + + + + +def calc_IfcFaceBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + + + + + + + + + + + + + + + + + + + +class IfcFacilityPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFacilityPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert ((predefinedtype != IfcBridgePartTypeEnum.USERDEFINED) or (predefinedtype != IfcRailwayPartTypeEnum.USERDEFINED) or (predefinedtype != IfcRoadPartTypeEnum.USERDEFINED) or (predefinedtype != IfcMarinePartTypeEnum.USERDEFINED) or (predefinedtype != IfcFacilityPartCommonTypeEnum.USERDEFINED)) or (((predefinedtype == IfcBridgePartTypeEnum.USERDEFINED) or (predefinedtype == IfcRailwayPartTypeEnum.USERDEFINED) or (predefinedtype == IfcRoadPartTypeEnum.USERDEFINED) or (predefinedtype == IfcMarinePartTypeEnum.USERDEFINED) or (predefinedtype == IfcFacilityPartCommonTypeEnum.USERDEFINED)) and exists(self.ObjectType)) + + + + + + + + +class IfcFan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFan_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcfantype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFanType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFanType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFeatureElement_NotContained: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElement" + RULE_NAME = "NotContained" + + @staticmethod + def __call__(self): + containedinstructure = self.ContainedInStructure + + assert sizeof(containedinstructure) == 0 + + + + + + + + +class IfcFeatureElementSubtraction_HasNoSubtraction: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "HasNoSubtraction" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasOpenings) == 0 + + + + +class IfcFeatureElementSubtraction_IsNotFilling: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "IsNotFilling" + + @staticmethod + def __call__(self): + + + assert sizeof(self.FillsVoids) == 0 + + + + + +class IfcFillAreaStyle_MaxOneColour: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneColour" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x3_rc3.ifccolour' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_MaxOneExtHatchStyle: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneExtHatchStyle" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x3_rc3.ifcexternallydefinedhatchstyle' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_ConsistentHatchStyleDef: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "ConsistentHatchStyleDef" + + @staticmethod + def __call__(self): + + + assert IfcCorrectFillAreaStyle(self.FillStyles) + + + + + +class IfcFillAreaStyleHatching_PatternStart2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "PatternStart2D" + + @staticmethod + def __call__(self): + patternstart = self.PatternStart + + assert (not exists(patternstart)) or (patternstart.Dim == 2) + + + + +class IfcFillAreaStyleHatching_RefHatchLine2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "RefHatchLine2D" + + @staticmethod + def __call__(self): + pointofreferencehatchline = self.PointOfReferenceHatchLine + + assert (not exists(pointofreferencehatchline)) or (pointofreferencehatchline.Dim == 2) + + + + + + + + +class IfcFilter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFilter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcfiltertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFilterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFireSuppressionTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFireSuppressionTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcfiresuppressionterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFireSuppressionTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + +class IfcFlowInstrument_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowInstrument_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcflowinstrumenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowInstrumentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrumentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFlowMeter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowMeter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcflowmetertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowMeterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFooting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFooting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcfootingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFootingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFootingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcFurniture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFurniture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcfurnituretype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFurnitureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurnitureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeographicElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcGeographicElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcgeographicelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcGeographicElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeometricCurveSet_NoSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricCurveSet" + RULE_NAME = "NoSurfaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Elements if 'ifc4x3_rc3.ifcsurface' in typeof(temp)])) == 0 + + + + + +class IfcGeometricRepresentationContext_North2D: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationContext" + RULE_NAME = "North2D" + + @staticmethod + def __call__(self): + truenorth = self.TrueNorth + + assert (not exists(truenorth)) or (hiindex(truenorth.DirectionRatios) == 2) + + + + + + + + +class IfcGeometricRepresentationSubContext_ParentNoSub: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "ParentNoSub" + + @staticmethod + def __call__(self): + parentcontext = self.ParentContext + + assert not 'ifc4x3_rc3.ifcgeometricrepresentationsubcontext' in typeof(parentcontext) + + + + +class IfcGeometricRepresentationSubContext_UserTargetProvided: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "UserTargetProvided" + + @staticmethod + def __call__(self): + targetview = self.TargetView + userdefinedtargetview = self.UserDefinedTargetView + + assert (targetview != IfcGeometricProjectionEnum.USERDEFINED) or ((targetview == IfcGeometricProjectionEnum.USERDEFINED) and exists(userdefinedtargetview)) + + + + +class IfcGeometricRepresentationSubContext_NoCoordOperation: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "NoCoordOperation" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasCoordinateOperation) == 0 + + + + +def calc_IfcGeometricRepresentationSubContext_WorldCoordinateSystem(self): + parentcontext = self.ParentContext + return \ + parentcontext.WorldCoordinateSystem + + + +def calc_IfcGeometricRepresentationSubContext_CoordinateSpaceDimension(self): + parentcontext = self.ParentContext + return \ + parentcontext.CoordinateSpaceDimension + + + +def calc_IfcGeometricRepresentationSubContext_TrueNorth(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.TrueNorth,IfcConvertDirectionInto2D(self.WorldCoordinateSystem.P[2 - 1])) + + + +def calc_IfcGeometricRepresentationSubContext_Precision(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.Precision,1) + + + + +class IfcGeometricSet_ConsistentDim: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricSet" + RULE_NAME = "ConsistentDim" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof([temp for temp in elements if temp.Dim != (elements[1 - 1].Dim)])) == 0 + + + + +def calc_IfcGeometricSet_Dim(self): + elements = self.Elements + return \ + elements[1 - 1].Dim + + + + + + + + + + + + + + + + + + + +def calc_IfcGradientCurve_RelativeElevation(self): + + return \ + IfcGradient(self) + + + + + + + +class IfcGridAxis_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + axiscurve = self.AxisCurve + + assert axiscurve.Dim == 2 + + + + +class IfcGridAxis_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + partofw = self.PartOfW + partofv = self.PartOfV + partofu = self.PartOfU + + assert (sizeof(partofu) == 1) ^ (sizeof(partofv) == 1) ^ (sizeof(partofw) == 1) + + + + + + + + + + + +def calc_IfcHalfSpaceSolid_Dim(self): + + return \ + 3 + + + + +class IfcHeatExchanger_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHeatExchanger_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcheatexchangertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHeatExchangerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchangerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcHumidifier_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHumidifier_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifchumidifiertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHumidifierType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifierType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + flangethickness = self.FlangeThickness + + assert (2. * flangethickness) < overalldepth + + + + +class IfcIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + webthickness = self.WebThickness + + assert webthickness < overallwidth + + + + +class IfcIShapeProfileDef_ValidFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFilletRadius" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + overalldepth = self.OverallDepth + webthickness = self.WebThickness + flangethickness = self.FlangeThickness + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or ((filletradius <= ((overallwidth - webthickness) / 2.)) and (filletradius <= ((overalldepth - (2. * flangethickness)) / 2.))) + + + + + + + + +class IfcImpactProtectionDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or ((predefinedtype != IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED)) or (((predefinedtype == IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or (predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) or (predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED)) and exists(self.ObjectType)) + + + + +class IfcImpactProtectionDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcimpactprotectiondevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcImpactProtectionDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert ((predefinedtype != IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED)) or (((predefinedtype == IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or (predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) or (predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED)) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcIndexedPolyCurve_Consecutive: + SCOPE = "entity" + TYPE_NAME = "IfcIndexedPolyCurve" + RULE_NAME = "Consecutive" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (not exists(segments)) or IfcConsecutiveSegments(segments) + + + + + + + + + + + + + + + + + +class IfcInterceptor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcInterceptor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcinterceptortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcInterceptorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIntersectionCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + +class IfcIntersectionCurve_DistinctSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "DistinctSurfaces" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) != (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + + + + + + + + + + + +class IfcJunctionBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcJunctionBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcjunctionboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcJunctionBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcLShapeProfileDef_ValidThickness: + SCOPE = "entity" + TYPE_NAME = "IfcLShapeProfileDef" + RULE_NAME = "ValidThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + thickness = self.Thickness + + assert (thickness < depth) and ((not exists(width)) or (thickness < width)) + + + + + +class IfcLaborResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcLaborResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +class IfcLamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifclamptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcLightFixture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLightFixture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifclightfixturetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLightFixtureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixtureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcLine_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcLine" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + pnt = self.Pnt + dir = self.Dir + + assert dir.Dim == pnt.Dim + + + + + + + + + + + + + + +class IfcLiquidTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLiquidTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcLiquidTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLiquidTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcliquidterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLiquidTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLiquidTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcLiquidTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcLocalPlacement_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcLocalPlacement" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + placementrelto = self.PlacementRelTo + relativeplacement = self.RelativePlacement + + assert IfcCorrectLocalPlacement(relativeplacement,placementrelto) + + + + + + + + + + + + + + + + + +class IfcMarineFacility_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMarineFacility" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMarineFacilityTypeEnum.USERDEFINED) or ((predefinedtype == IfcMarineFacilityTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + + + + + + + + + + +class IfcMaterialDefinitionRepresentation_OnlyStyledRepresentations: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialDefinitionRepresentation" + RULE_NAME = "OnlyStyledRepresentations" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x3_rc3.ifcstyledrepresentation' in typeof(temp)])) == 0 + + + + + +class IfcMaterialLayer_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialLayer" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + +def calc_IfcMaterialLayerSet_TotalThickness(self): + + return \ + IfcMlsTotalThickness(self) + + + + + + + + + + + + + +class IfcMaterialProfile_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialProfile" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMechanicalFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMechanicalFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcmechanicalfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMechanicalFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMedicalDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMedicalDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcmedicaldevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMedicalDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMember_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMember_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcmembertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMemberStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcMemberStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc3.ifcrelassociates.relatedobjects') if ('ifc4x3_rc3.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc3.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcMemberType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMemberType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcMirroredProfileDef_Operator(self): + + return \ + IfcCartesianTransformationOperator2D(Axis1=IfcDirection(DirectionRatios=[-1.,0.]), Axis2=IfcDirection(DirectionRatios=[0.,1.]), LocalOrigin=IfcCartesianPoint(Coordinates=[0.,0.]), Scale=1.) + + + + +class IfcMobileTelecommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMobileTelecommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcmobiletelecommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMobileTelecommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcMooringDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMooringDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMooringDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMooringDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcmooringdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMooringDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMooringDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMooringDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMotorConnection_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMotorConnection_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcmotorconnectiontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMotorConnectionType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnectionType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcNamedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcNamedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert IfcCorrectDimensions(self.UnitType,self.Dimensions) + + + + + +class IfcNavigationElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcNavigationElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcNavigationElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcNavigationElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcnavigationelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcNavigationElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcNavigationElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcNavigationElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + isdefinedby = self.IsDefinedBy + + assert (sizeof(isdefinedby) == 0) or IfcUniqueDefinitionNames(isdefinedby) + + + + + + + + + + + +class IfcObjective_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcObjective" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + objectivequalifier = self.ObjectiveQualifier + + assert (objectivequalifier != IfcObjectiveEnum.USERDEFINED) or ((objectivequalifier == IfcObjectiveEnum.USERDEFINED) and exists(self.UserDefinedQualifier)) + + + + + +class IfcOccupant_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcOccupant" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not predefinedtype == IfcOccupantTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcOffsetCurve2D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve2D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 2 + + + + + +class IfcOffsetCurve3D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve3D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 3 + + + + + + + + +class IfcOpenCrossProfileDef_CorrectProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrectProfileType" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == IfcProfileTypeEnum.CURVE + + + + +class IfcOpenCrossProfileDef_CorrespondingSlopeWidths: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrespondingSlopeWidths" + + @staticmethod + def __call__(self): + widths = self.Widths + slopes = self.Slopes + + assert sizeof(slopes) == sizeof(widths) + + + + +class IfcOpenCrossProfileDef_CorrespondingTags: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrespondingTags" + + @staticmethod + def __call__(self): + slopes = self.Slopes + tags = self.Tags + + assert (not exists(tags)) or (sizeof(tags) == (sizeof(slopes) + 1)) + + + + + + + + +class IfcOpeningElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOpeningElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcOpeningElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcOpeningElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + + + + +class IfcOrientedEdge_EdgeElementNotOriented: + SCOPE = "entity" + TYPE_NAME = "IfcOrientedEdge" + RULE_NAME = "EdgeElementNotOriented" + + @staticmethod + def __call__(self): + edgeelement = self.EdgeElement + + assert not 'ifc4x3_rc3.ifcorientededge' in typeof(edgeelement) + + + + +def calc_IfcOrientedEdge_EdgeStart(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeStart,edgeelement.EdgeEnd) + + + +def calc_IfcOrientedEdge_EdgeEnd(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeEnd,edgeelement.EdgeStart) + + + + + + + +class IfcOutlet_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcOutlet_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcoutlettype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcOutletType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutletType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcOwnerHistory_CorrectChangeAction: + SCOPE = "entity" + TYPE_NAME = "IfcOwnerHistory" + RULE_NAME = "CorrectChangeAction" + + @staticmethod + def __call__(self): + changeaction = self.ChangeAction + lastmodifieddate = self.LastModifiedDate + + assert exists(lastmodifieddate) or ((not exists(lastmodifieddate)) and (not exists(changeaction))) or ((not exists(lastmodifieddate)) and exists(changeaction) and ((changeaction == IfcChangeActionEnum.NOTDEFINED) or (changeaction == IfcChangeActionEnum.NOCHANGE))) + + + + + + + + +class IfcPath_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcPath" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcPathHeadToTail(self) + + + + + +class IfcPavement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPavement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPavementTypeEnum.USERDEFINED) or ((predefinedtype == IfcPavementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPavement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPavement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcpavementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPavementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPavementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPavementTypeEnum.USERDEFINED) or ((predefinedtype == IfcPavementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPcurve_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcPcurve" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + referencecurve = self.ReferenceCurve + + assert referencecurve.Dim == 2 + + + + + + + + + + + + + + +class IfcPerson_IdentifiablePerson: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "IdentifiablePerson" + + @staticmethod + def __call__(self): + identification = self.Identification + familyname = self.FamilyName + givenname = self.GivenName + + assert exists(identification) or exists(familyname) or exists(givenname) + + + + +class IfcPerson_ValidSetOfNames: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "ValidSetOfNames" + + @staticmethod + def __call__(self): + familyname = self.FamilyName + givenname = self.GivenName + middlenames = self.MiddleNames + + assert (not exists(middlenames)) or exists(familyname) or exists(givenname) + + + + + + + + +class IfcPhysicalComplexQuantity_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert (sizeof([temp for temp in hasquantities if self == temp])) == 0 + + + + +class IfcPhysicalComplexQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert IfcUniqueQuantityNames(hasquantities) + + + + + + + + + + + +class IfcPile_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPile_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcpiletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPileType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPileType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcpipefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcpipesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPixelTexture_MinPixelInS: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInS" + + @staticmethod + def __call__(self): + width = self.Width + + assert width >= 1 + + + + +class IfcPixelTexture_MinPixelInT: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInT" + + @staticmethod + def __call__(self): + height = self.Height + + assert height >= 1 + + + + +class IfcPixelTexture_NumberOfColours: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "NumberOfColours" + + @staticmethod + def __call__(self): + colourcomponents = self.ColourComponents + + assert 1 <= colourcomponents <= 4 + + + + +class IfcPixelTexture_SizeOfPixelList: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "SizeOfPixelList" + + @staticmethod + def __call__(self): + width = self.Width + height = self.Height + pixel = self.Pixel + + assert sizeof(pixel) == (width * height) + + + + +class IfcPixelTexture_PixelAsByteAndSameLength: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "PixelAsByteAndSameLength" + + @staticmethod + def __call__(self): + pixel = self.Pixel + + assert (sizeof([temp for temp in pixel if ((blength(temp) % 8) == 0) and (blength(temp) == (blength(pixel[1 - 1])))])) == sizeof(pixel) + + + + + +def calc_IfcPlacement_Dim(self): + location = self.Location + return \ + location.Dim + + + + + + + + + + + + + + + + +class IfcPlate_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPlate_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcplatetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPlateStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcPlateStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc3.ifcrelassociates.relatedobjects') if ('ifc4x3_rc3.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc3.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcPlateType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlateType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcPointByDistanceExpression_Dim(self): + basiscurve = self.BasisCurve + return \ + basiscurve.Dim + + + + +def calc_IfcPointOnCurve_Dim(self): + basiscurve = self.BasisCurve + return \ + basiscurve.Dim + + + + +def calc_IfcPointOnSurface_Dim(self): + basissurface = self.BasisSurface + return \ + basissurface.Dim + + + + +class IfcPolyLoop_AllPointsSameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyLoop" + RULE_NAME = "AllPointsSameDim" + + @staticmethod + def __call__(self): + polygon = self.Polygon + + assert (sizeof([temp for temp in polygon if temp.Dim != (polygon[1 - 1].Dim)])) == 0 + + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryDim" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert polygonalboundary.Dim == 2 + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryType: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryType" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert (sizeof(typeof(polygonalboundary) * ['ifc4x3_rc3.ifcpolyline','ifc4x3_rc3.ifccompositecurve'])) == 1 + + + + + + + + +class IfcPolyline_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyline" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + points = self.Points + + assert (sizeof([temp for temp in points if temp.Dim != (points[1 - 1].Dim)])) == 0 + + + + + +class IfcPolynomialCurve_ValidCoefficients: + SCOPE = "entity" + TYPE_NAME = "IfcPolynomialCurve" + RULE_NAME = "ValidCoefficients" + + @staticmethod + def __call__(self): + coefficientsx = self.CoefficientsX + coefficientsy = self.CoefficientsY + coefficientsz = self.CoefficientsZ + + assert (exists(coefficientsx) and exists(coefficientsy)) or (exists(coefficientsx) and exists(coefficientsz)) or (exists(coefficientsy) and exists(coefficientsz)) or (exists(coefficientsx) and exists(coefficientsy) and exists(coefficientsz)) + + + + +class IfcPolynomialCurve_CorrectPositionDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolynomialCurve" + RULE_NAME = "CorrectPositionDim" + + @staticmethod + def __call__(self): + position = self.Position + coefficientsz = self.CoefficientsZ + + assert ((position.Dim == 2) and (not exists(coefficientsz))) or (position.Dim == 3) + + + + + + + + +class IfcPositioningElement_HasPlacement: + SCOPE = "entity" + TYPE_NAME = "IfcPositioningElement" + RULE_NAME = "HasPlacement" + + @staticmethod + def __call__(self): + + + assert exists(self.ObjectPlacement) + + + + + +class IfcPostalAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPostalAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + internallocation = self.InternalLocation + addresslines = self.AddressLines + postalbox = self.PostalBox + town = self.Town + region = self.Region + postalcode = self.PostalCode + country = self.Country + + assert exists(internallocation) or exists(addresslines) or exists(postalbox) or exists(postalcode) or exists(town) or exists(region) or exists(country) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPresentationLayerAssignment_ApplicableItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerAssignment" + RULE_NAME = "ApplicableItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x3_rc3.ifcshaperepresentation','ifc4x3_rc3.ifcgeometricrepresentationitem','ifc4x3_rc3.ifcmappeditem'])) == 1])) == sizeof(assigneditems) + + + + + +class IfcPresentationLayerWithStyle_ApplicableOnlyToItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerWithStyle" + RULE_NAME = "ApplicableOnlyToItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x3_rc3.ifcgeometricrepresentationitem','ifc4x3_rc3.ifcmappeditem'])) >= 1])) == sizeof(assigneditems) + + + + + + + + +class IfcProcedure_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProcedure_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcProcedureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + + + + +class IfcProduct_PlacementForShapeRepresentation: + SCOPE = "entity" + TYPE_NAME = "IfcProduct" + RULE_NAME = "PlacementForShapeRepresentation" + + @staticmethod + def __call__(self): + objectplacement = self.ObjectPlacement + representation = self.Representation + + assert (exists(representation) and exists(objectplacement)) or (exists(representation) and ((sizeof([temp for temp in representation.Representations if 'ifc4x3_rc3.ifcshaperepresentation' in typeof(temp)])) == 0)) or (not exists(representation)) + + + + + +class IfcProductDefinitionShape_OnlyShapeModel: + SCOPE = "entity" + TYPE_NAME = "IfcProductDefinitionShape" + RULE_NAME = "OnlyShapeModel" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x3_rc3.ifcshapemodel' in typeof(temp)])) == 0 + + + + + + + + + + + + + + +class IfcProject_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProject_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert (not exists(self.RepresentationContexts)) or ((sizeof([temp for temp in self.RepresentationContexts if 'ifc4x3_rc3.ifcgeometricrepresentationsubcontext' in typeof(temp)])) == 0) + + + + +class IfcProject_NoDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "NoDecomposition" + + @staticmethod + def __call__(self): + + + assert sizeof(self.Decomposes) == 0 + + + + + + + + + + + +class IfcProjectedCRS_IsLengthUnit: + SCOPE = "entity" + TYPE_NAME = "IfcProjectedCRS" + RULE_NAME = "IsLengthUnit" + + @staticmethod + def __call__(self): + mapunit = self.MapUnit + + assert (not exists(mapunit)) or (mapunit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + + +class IfcProjectionElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProjectionElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProjectionElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcProjectionElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcPropertyBoundedValue_SameUnitUpperLower: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperLower" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + lowerboundvalue = self.LowerBoundValue + + assert (not exists(upperboundvalue)) or (not exists(lowerboundvalue)) or (typeof(upperboundvalue) == typeof(lowerboundvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitUpperSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperSet" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(upperboundvalue)) or (not exists(setpointvalue)) or (typeof(upperboundvalue) == typeof(setpointvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitLowerSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitLowerSet" + + @staticmethod + def __call__(self): + lowerboundvalue = self.LowerBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(lowerboundvalue)) or (not exists(setpointvalue)) or (typeof(lowerboundvalue) == typeof(setpointvalue)) + + + + + + + + +class IfcPropertyDependencyRelationship_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyDependencyRelationship" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + dependingproperty = self.DependingProperty + dependantproperty = self.DependantProperty + + assert dependingproperty != dependantproperty + + + + + +class IfcPropertyEnumeratedValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeratedValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + enumerationvalues = self.EnumerationValues + enumerationreference = self.EnumerationReference + + assert (not exists(enumerationreference)) or (not exists(enumerationvalues)) or ((sizeof([temp for temp in enumerationvalues if temp in enumerationreference.EnumerationValues])) == sizeof(enumerationvalues)) + + + + + +class IfcPropertyEnumeration_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeration" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.EnumerationValues if not (typeof(self.EnumerationValues[1 - 1])) == typeof(temp)])) == 0 + + + + + +class IfcPropertyListValue_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyListValue" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.ListValues if not (typeof(self.ListValues[1 - 1])) == typeof(temp)])) == 0 + + + + + + + + +class IfcPropertySet_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySet_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + + + + +class IfcPropertySetTemplate_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySetTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + + + + + +class IfcPropertyTableValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + definedvalues = self.DefinedValues + + assert ((not exists(definingvalues)) and (not exists(definedvalues))) or (sizeof(definingvalues) == sizeof(definedvalues)) + + + + +class IfcPropertyTableValue_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + + assert (not exists(definingvalues)) or ((sizeof([temp for temp in self.DefiningValues if typeof(temp) != (typeof(self.DefiningValues[1 - 1]))])) == 0) + + + + +class IfcPropertyTableValue_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + definedvalues = self.DefinedValues + + assert (not exists(definedvalues)) or ((sizeof([temp for temp in self.DefinedValues if typeof(temp) != (typeof(self.DefinedValues[1 - 1]))])) == 0) + + + + + + + + + + + +class IfcProtectiveDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcprotectivedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcprotectivedevicetrippingunittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProtectiveDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProxy_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcProxy" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcPump_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPump_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcpumptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPumpType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPumpType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcQuantityArea_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.AREAUNIT) + + + + +class IfcQuantityArea_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + areavalue = self.AreaValue + + assert areavalue >= 0. + + + + + +class IfcQuantityCount_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityCount" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + countvalue = self.CountValue + + assert countvalue >= 0. + + + + + +class IfcQuantityLength_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + +class IfcQuantityLength_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + lengthvalue = self.LengthValue + + assert lengthvalue >= 0. + + + + + + + + +class IfcQuantityTime_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.TIMEUNIT) + + + + +class IfcQuantityTime_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + timevalue = self.TimeValue + + assert timevalue >= 0. + + + + + +class IfcQuantityVolume_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.VOLUMEUNIT) + + + + +class IfcQuantityVolume_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + volumevalue = self.VolumeValue + + assert volumevalue >= 0. + + + + + +class IfcQuantityWeight_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.MASSUNIT) + + + + +class IfcQuantityWeight_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + weightvalue = self.WeightValue + + assert weightvalue >= 0. + + + + + +class IfcRail_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRail" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRail_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRail" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcrailtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRailing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRailing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcrailingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRailway_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcRailway" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailwayTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcRamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcramptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRampFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcrampflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRationalBSplineCurveWithKnots_SameNumOfWeightsAndPoints: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "SameNumOfWeightsAndPoints" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert sizeof(weightsdata) == sizeof(self.ControlPointsList) + + + + +class IfcRationalBSplineCurveWithKnots_WeightsGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "WeightsGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcCurveWeightsPositive(self) + + + + +def calc_IfcRationalBSplineCurveWithKnots_Weights(self): + weightsdata = self.WeightsData + return \ + IfcListToArray(weightsdata,0,self.UpperIndexOnControlPoints) + + + + +class IfcRationalBSplineSurfaceWithKnots_CorrespondingWeightsDataLists: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingWeightsDataLists" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert (sizeof(weightsdata) == sizeof(self.ControlPointsList)) and ((sizeof(weightsdata[1 - 1])) == (sizeof(self.ControlPointsList[1 - 1]))) + + + + +class IfcRationalBSplineSurfaceWithKnots_WeightValuesGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "WeightValuesGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcSurfaceWeightsPositive(self) + + + + +def calc_IfcRationalBSplineSurfaceWithKnots_Weights(self): + uupper = self.UUpper + vupper = self.VUpper + weightsdata = self.WeightsData + return \ + IfcMakeArrayOfArray(weightsdata,0,uupper,0,vupper) + + + + +class IfcRectangleHollowProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert (wallthickness < (self.XDim / 2.)) and (wallthickness < (self.YDim / 2.)) + + + + +class IfcRectangleHollowProfileDef_ValidInnerRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidInnerRadius" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + innerfilletradius = self.InnerFilletRadius + + assert (not exists(innerfilletradius)) or ((innerfilletradius <= ((self.XDim / 2.) - wallthickness)) and (innerfilletradius <= ((self.YDim / 2.) - wallthickness))) + + + + +class IfcRectangleHollowProfileDef_ValidOuterRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidOuterRadius" + + @staticmethod + def __call__(self): + outerfilletradius = self.OuterFilletRadius + + assert (not exists(outerfilletradius)) or ((outerfilletradius <= (self.XDim / 2.)) and (outerfilletradius <= (self.YDim / 2.))) + + + + + + + + + + + +class IfcRectangularTrimmedSurface_U1AndU2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "U1AndU2Different" + + @staticmethod + def __call__(self): + u1 = self.U1 + u2 = self.U2 + + assert u1 != u2 + + + + +class IfcRectangularTrimmedSurface_V1AndV2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "V1AndV2Different" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + + assert v1 != v2 + + + + +class IfcRectangularTrimmedSurface_UsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "UsenseCompatible" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + u1 = self.U1 + u2 = self.U2 + usense = self.Usense + + assert (('ifc4x3_rc3.ifcelementarysurface' in typeof(basissurface)) and (not 'ifc4x3_rc3.ifcplane' in typeof(basissurface))) or ('ifc4x3_rc3.ifcsurfaceofrevolution' in typeof(basissurface)) or (usense == (u2 > u1)) + + + + +class IfcRectangularTrimmedSurface_VsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "VsenseCompatible" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + vsense = self.Vsense + + assert vsense == (v2 > v1) + + + + + + + + + + + + + + + + + +class IfcReinforcedSoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcedSoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcedSoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcedSoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcReinforcingBar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingBar_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcreinforcingbartype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingBarType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + +class IfcReinforcingBarType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + + + + + + + + +class IfcReinforcingMesh_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingMesh_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcreinforcingmeshtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingMeshType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + +class IfcReinforcingMeshType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + + +class IfcRelAggregates_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAggregates" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelAssigns_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssigns" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatedobjects = self.RelatedObjects + relatedobjectstype = self.RelatedObjectsType + + assert IfcCorrectObjectAssignment(relatedobjectstype,relatedobjects) + + + + + +class IfcRelAssignsToActor_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToActor" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingactor = self.RelatingActor + + assert (sizeof([temp for temp in self.RelatedObjects if relatingactor == temp])) == 0 + + + + + +class IfcRelAssignsToControl_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToControl" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontrol = self.RelatingControl + + assert (sizeof([temp for temp in self.RelatedObjects if relatingcontrol == temp])) == 0 + + + + + +class IfcRelAssignsToGroup_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToGroup" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatinggroup = self.RelatingGroup + + assert (sizeof([temp for temp in self.RelatedObjects if relatinggroup == temp])) == 0 + + + + + + + + +class IfcRelAssignsToProcess_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProcess" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + + assert (sizeof([temp for temp in self.RelatedObjects if relatingprocess == temp])) == 0 + + + + + +class IfcRelAssignsToProduct_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProduct" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingproduct = self.RelatingProduct + + assert (sizeof([temp for temp in self.RelatedObjects if relatingproduct == temp])) == 0 + + + + + +class IfcRelAssignsToResource_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToResource" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingresource = self.RelatingResource + + assert (sizeof([temp for temp in self.RelatedObjects if relatingresource == temp])) == 0 + + + + + + + + + + + + + + + + + + + + + + + +class IfcRelAssociatesMaterial_NoVoidElement: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "NoVoidElement" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if ('ifc4x3_rc3.ifcfeatureelementsubtraction' in typeof(temp)) or ('ifc4x3_rc3.ifcvirtualelement' in typeof(temp))])) == 0 + + + + +class IfcRelAssociatesMaterial_AllowedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "AllowedElements" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if (sizeof(typeof(temp) * ['ifc4x3_rc3.ifcelement','ifc4x3_rc3.ifcelementtype','ifc4x3_rc3.ifcwindowstyle','ifc4x3_rc3.ifcdoorstyle','ifc4x3_rc3.ifcstructuralmember','ifc4x3_rc3.ifcport'])) == 0])) == 0 + + + + + + + + + + + +class IfcRelConnectsElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelConnectsPathElements_NormalizedRelatingPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatingPriorities" + + @staticmethod + def __call__(self): + relatingpriorities = self.RelatingPriorities + + assert (sizeof(relatingpriorities) == 0) or ((sizeof([temp for temp in relatingpriorities if 0 <= temp <= 100])) == sizeof(relatingpriorities)) + + + + +class IfcRelConnectsPathElements_NormalizedRelatedPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatedPriorities" + + @staticmethod + def __call__(self): + relatedpriorities = self.RelatedPriorities + + assert (sizeof(relatedpriorities) == 0) or ((sizeof([temp for temp in relatedpriorities if 0 <= temp <= 100])) == sizeof(relatedpriorities)) + + + + + + + + +class IfcRelConnectsPorts_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPorts" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingport = self.RelatingPort + relatedport = self.RelatedPort + + assert relatingport != relatedport + + + + + + + + + + + + + + + + + +class IfcRelContainedInSpatialStructure_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRelContainedInSpatialStructure" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if 'ifc4x3_rc3.ifcspatialstructureelement' in typeof(temp)])) == 0 + + + + + + + + + + + +class IfcRelDeclares_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelDeclares" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontext = self.RelatingContext + relateddefinitions = self.RelatedDefinitions + + assert (sizeof([temp for temp in relateddefinitions if relatingcontext == temp])) == 0 + + + + + + + + + + + + + + +class IfcRelDefinesByProperties_NoRelatedTypeObject: + SCOPE = "entity" + TYPE_NAME = "IfcRelDefinesByProperties" + RULE_NAME = "NoRelatedTypeObject" + + @staticmethod + def __call__(self): + + + assert (sizeof([types for types in self.RelatedObjects if 'ifc4x3_rc3.ifctypeobject' in typeof(types)])) == 0 + + + + + + + + + + + + + + + + + +class IfcRelInterferesElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelInterferesElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelNests_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelNests" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelPositions_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelPositions" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingpositioningelement = self.RelatingPositioningElement + relatedproducts = self.RelatedProducts + + assert (sizeof([temp for temp in relatedproducts if relatingpositioningelement == temp])) == 0 + + + + + + + + +class IfcRelReferencedInSpatialStructure_AllowedRelatedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelReferencedInSpatialStructure" + RULE_NAME = "AllowedRelatedElements" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if ('ifc4x3_rc3.ifcspatialstructureelement' in typeof(temp)) and (not 'ifc4x3_rc3.ifcspace' in typeof(temp))])) == 0 + + + + + +class IfcRelSequence_AvoidInconsistentSequence: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "AvoidInconsistentSequence" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + relatedprocess = self.RelatedProcess + + assert relatingprocess != relatedprocess + + + + +class IfcRelSequence_CorrectSequenceType: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "CorrectSequenceType" + + @staticmethod + def __call__(self): + sequencetype = self.SequenceType + userdefinedsequencetype = self.UserDefinedSequenceType + + assert (sequencetype != IfcSequenceEnum.USERDEFINED) or ((sequencetype == IfcSequenceEnum.USERDEFINED) and exists(userdefinedsequencetype)) + + + + + + + + +class IfcRelSpaceBoundary_CorrectPhysOrVirt: + SCOPE = "entity" + TYPE_NAME = "IfcRelSpaceBoundary" + RULE_NAME = "CorrectPhysOrVirt" + + @staticmethod + def __call__(self): + relatedbuildingelement = self.RelatedBuildingElement + physicalorvirtualboundary = self.PhysicalOrVirtualBoundary + + assert ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Physical) and (not 'ifc4x3_rc3.ifcvirtualelement' in typeof(relatedbuildingelement))) or ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Virtual) and (('ifc4x3_rc3.ifcvirtualelement' in typeof(relatedbuildingelement)) or ('ifc4x3_rc3.ifcopeningelement' in typeof(relatedbuildingelement)))) or (physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.NotDefined) + + + + + + + + + + + + + + + + + +class IfcReparametrisedCompositeCurveSegment_PositiveLengthParameter: + SCOPE = "entity" + TYPE_NAME = "IfcReparametrisedCompositeCurveSegment" + RULE_NAME = "PositiveLengthParameter" + + @staticmethod + def __call__(self): + paramlength = self.ParamLength + + assert paramlength > 0.0 + + + + + + + + + + + + + + +class IfcRepresentationMap_ApplicableMappedRepr: + SCOPE = "entity" + TYPE_NAME = "IfcRepresentationMap" + RULE_NAME = "ApplicableMappedRepr" + + @staticmethod + def __call__(self): + mappedrepresentation = self.MappedRepresentation + + assert 'ifc4x3_rc3.ifcshapemodel' in typeof(mappedrepresentation) + + + + + + + + + + + + + + + + + + + + +class IfcRevolvedAreaSolid_AxisStartInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisStartInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Location.Coordinates[3 - 1]) == 0.0 + + + + +class IfcRevolvedAreaSolid_AxisDirectionInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisDirectionInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Z.DirectionRatios[3 - 1]) == 0.0 + + + + +def calc_IfcRevolvedAreaSolid_AxisLine(self): + axis = self.Axis + return \ + IfcLine(Pnt=axis.Location, Dir=IfcVector(Orientation=axis.Z, Magnitude=1.0)) + + + + +class IfcRevolvedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + + + + + + + +class IfcRoad_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcRoad" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoadTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcRoof_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRoof_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcrooftype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRoofType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoofType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcRoundedRectangleProfileDef_ValidRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRoundedRectangleProfileDef" + RULE_NAME = "ValidRadius" + + @staticmethod + def __call__(self): + roundingradius = self.RoundingRadius + + assert (roundingradius <= (self.XDim / 2.)) and (roundingradius <= (self.YDim / 2.)) + + + + + +def calc_IfcSIUnit_Dimensions(self): + + return \ + IfcDimensionsForSiUnit(self.Name) + + + + +class IfcSanitaryTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSanitaryTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcsanitaryterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSanitaryTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSeamCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + +class IfcSeamCurve_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) == (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + + + + + + + + + + + +class IfcSectionedSolid_DirectrixIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "DirectrixIs3D" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSectionedSolid_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSolid_SectionsSameType: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "SectionsSameType" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (typeof(crosssections[1 - 1])) != typeof(temp)])) == 0 + + + + + +class IfcSectionedSolidHorizontal_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSolidHorizontal_NoLongitudinalOffsets: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "NoLongitudinalOffsets" + + @staticmethod + def __call__(self): + crosssectionpositions = self.CrossSectionPositions + + assert (sizeof([temp for temp in crosssectionpositions if exists(temp.Location.OffsetLongitudinal)])) == 0 + + + + + +class IfcSectionedSpine_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSpine_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSpine_SpineCurveDim: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "SpineCurveDim" + + @staticmethod + def __call__(self): + spinecurve = self.SpineCurve + + assert spinecurve.Dim == 3 + + + + +def calc_IfcSectionedSpine_Dim(self): + + return \ + 3 + + + + + + + + + + + + + +class IfcSensor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSensor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcsensortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSensorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcShadingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcShadingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcshadingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcShadingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcShapeModel_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcShapeModel" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + ofshapeaspect = self.OfShapeAspect + + assert (sizeof(self.OfProductRepresentation) == 1) ^ (sizeof(self.RepresentationMap) == 1) ^ (sizeof(ofshapeaspect) == 1) + + + + + +class IfcShapeRepresentation_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc3.ifcgeometricrepresentationcontext' in typeof(self.ContextOfItems) + + + + +class IfcShapeRepresentation_NoTopologicalItem: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "NoTopologicalItem" + + @staticmethod + def __call__(self): + items = self.Items + + assert (sizeof([temp for temp in items if ('ifc4x3_rc3.ifctopologicalrepresentationitem' in typeof(temp)) and (not (sizeof(['ifc4x3_rc3.ifcvertexpoint','ifc4x3_rc3.ifcedgecurve','ifc4x3_rc3.ifcfacesurface'] * typeof(temp))) == 1)])) == 0 + + + + +class IfcShapeRepresentation_HasRepresentationType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationType" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcShapeRepresentation_HasRepresentationIdentifier: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationIdentifier" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationIdentifier) + + + + +class IfcShapeRepresentation_CorrectItemsForType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectItemsForType" + + @staticmethod + def __call__(self): + + + assert IfcShapeRepresentationTypes(self.RepresentationType,self.Items) + + + + + +def calc_IfcShellBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + +class IfcSign_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSign" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSignTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSign_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSign" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcsigntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSignType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSignTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSignal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSignalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSignal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSignal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcsignaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSignalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSignalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + +class IfcSlab_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSlab_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcslabtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSlabElementedCase_HasDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcSlabElementedCase" + RULE_NAME = "HasDecomposition" + + @staticmethod + def __call__(self): + + + assert hiindex(self.IsDecomposedBy) > 0 + + + + + +class IfcSlabStandardCase_HasMaterialLayerSetusage: + SCOPE = "entity" + TYPE_NAME = "IfcSlabStandardCase" + RULE_NAME = "HasMaterialLayerSetusage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc3.ifcrelassociates.relatedobjects') if ('ifc4x3_rc3.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc3.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcSlabType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlabType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSolarDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSolarDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcsolardevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSolarDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcSolidModel_Dim(self): + + return \ + 3 + + + + + + + +class IfcSpace_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpace_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcspacetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeater_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpaceHeater_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcspaceheatertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeaterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeaterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSpaceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcSpatialStructureElement_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialStructureElement" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + + + assert (hiindex(self.Decomposes) == 1) and ('ifc4x3_rc3.ifcrelaggregates' in (typeof(self.Decomposes[1 - 1]))) and (('ifc4x3_rc3.ifcproject' in (typeof(self.Decomposes[1 - 1].RelatingObject))) or ('ifc4x3_rc3.ifcspatialstructureelement' in (typeof(self.Decomposes[1 - 1].RelatingObject)))) + + + + + + + + +class IfcSpatialZone_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpatialZone_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcspatialzonetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpatialZoneType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZoneType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcStackTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStackTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcstackterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStackTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStair_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStair_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcstairtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStairFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcstairflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStairType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcStructuralAnalysisModel_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralAnalysisModel" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAnalysisModelTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralAnalysisModel_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralAnalysisModel" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAnalysisModelTypeEnum.USERDEFINED) or ((predefinedtype == IfcAnalysisModelTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcStructuralCurveAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralCurveAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveAction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert predefinedtype != IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + + + + + + + +class IfcStructuralCurveMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralCurveReaction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveReaction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.SINUS) and (predefinedtype != IfcStructuralCurveActivityTypeEnum.PARABOLA) + + + + + + + + +class IfcStructuralLinearAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc3.ifcstructuralloadlinearforce','ifc4x3_rc3.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + +class IfcStructuralLinearAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralCurveActivityTypeEnum.CONST + + + + + + + + +class IfcStructuralLoadCase_IsLoadCasePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadCase" + RULE_NAME = "IsLoadCasePredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcLoadGroupTypeEnum.LOAD_CASE + + + + + +class IfcStructuralLoadConfiguration_ValidListSize: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadConfiguration" + RULE_NAME = "ValidListSize" + + @staticmethod + def __call__(self): + values = self.Values + locations = self.Locations + + assert (not exists(locations)) or (sizeof(locations) == sizeof(values)) + + + + + +class IfcStructuralLoadGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + actiontype = self.ActionType + actionsource = self.ActionSource + + assert ((predefinedtype != IfcLoadGroupTypeEnum.USERDEFINED) and (actiontype != IfcActionTypeEnum.USERDEFINED) and (actionsource != IfcActionSourceTypeEnum.USERDEFINED)) or exists(self.ObjectType) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcStructuralPlanarAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc3.ifcstructuralloadplanarforce','ifc4x3_rc3.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + +class IfcStructuralPlanarAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralSurfaceActivityTypeEnum.CONST + + + + + +class IfcStructuralPointAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc3.ifcstructuralloadsingleforce','ifc4x3_rc3.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralPointReaction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointReaction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc3.ifcstructuralloadsingleforce','ifc4x3_rc3.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralResultGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralResultGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + theorytype = self.TheoryType + + assert (theorytype != IfcAnalysisTheoryTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcStructuralSurfaceAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralSurfaceAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceReaction_HasPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceReaction" + RULE_NAME = "HasPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStyledItem_ApplicableItem: + SCOPE = "entity" + TYPE_NAME = "IfcStyledItem" + RULE_NAME = "ApplicableItem" + + @staticmethod + def __call__(self): + item = self.Item + + assert not 'ifc4x3_rc3.ifcstyleditem' in typeof(item) + + + + + +class IfcStyledRepresentation_OnlyStyledItems: + SCOPE = "entity" + TYPE_NAME = "IfcStyledRepresentation" + RULE_NAME = "OnlyStyledItems" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x3_rc3.ifcstyleditem' in typeof(temp)])) == 0 + + + + + +class IfcSubContractResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcSubContractResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +def calc_IfcSurface_Dim(self): + + return \ + 3 + + + + +class IfcSurfaceCurve_CurveIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIs3D" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert curve3d.Dim == 3 + + + + +class IfcSurfaceCurve_CurveIsNotPcurve: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIsNotPcurve" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert not 'ifc4x3_rc3.ifcpcurve' in typeof(curve3d) + + + + +def calc_IfcSurfaceCurve_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + + + + +class IfcSurfaceFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSurfaceFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcSurfaceOfLinearExtrusion_DepthGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceOfLinearExtrusion" + RULE_NAME = "DepthGreaterZero" + + @staticmethod + def __call__(self): + depth = self.Depth + + assert depth > 0. + + + + +def calc_IfcSurfaceOfLinearExtrusion_ExtrusionAxis(self): + extrudeddirection = self.ExtrudedDirection + depth = self.Depth + return \ + IfcVector(Orientation=extrudeddirection, Magnitude=depth) + + + + +def calc_IfcSurfaceOfRevolution_AxisLine(self): + axisposition = self.AxisPosition + return \ + IfcLine(Pnt=axisposition.Location, Dir=IfcVector(Orientation=axisposition.Z, Magnitude=1.0)) + + + + +class IfcSurfaceReinforcementArea_SurfaceAndOrShearAreaSpecified: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "SurfaceAndOrShearAreaSpecified" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + surfacereinforcement2 = self.SurfaceReinforcement2 + shearreinforcement = self.ShearReinforcement + + assert exists(surfacereinforcement1) or exists(surfacereinforcement2) or exists(shearreinforcement) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea1: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea1" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + + assert (not exists(surfacereinforcement1)) or (((surfacereinforcement1[1 - 1]) >= 0.) and ((surfacereinforcement1[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement1) == 1) or ((surfacereinforcement1[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea2: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea2" + + @staticmethod + def __call__(self): + surfacereinforcement2 = self.SurfaceReinforcement2 + + assert (not exists(surfacereinforcement2)) or (((surfacereinforcement2[1 - 1]) >= 0.) and ((surfacereinforcement2[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement2) == 1) or ((surfacereinforcement2[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea3: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea3" + + @staticmethod + def __call__(self): + shearreinforcement = self.ShearReinforcement + + assert (not exists(shearreinforcement)) or (shearreinforcement >= 0.) + + + + + +class IfcSurfaceStyle_MaxOneShading: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneShading" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc3.ifcsurfacestyleshading' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneLighting: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneLighting" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc3.ifcsurfacestylelighting' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneRefraction: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneRefraction" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc3.ifcsurfacestylerefraction' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneTextures: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneTextures" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc3.ifcsurfacestylewithtextures' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneExtDefined: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneExtDefined" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc3.ifcexternallydefinedsurfacestyle' in typeof(style)])) <= 1 + + + + + + + + + + + + + + + + + + + + + + + +class IfcSweptAreaSolid_SweptAreaType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptAreaSolid" + RULE_NAME = "SweptAreaType" + + @staticmethod + def __call__(self): + sweptarea = self.SweptArea + + assert sweptarea.ProfileType == IfcProfileTypeEnum.Area + + + + + +class IfcSweptDiskSolid_DirectrixDim: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixDim" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSweptDiskSolid_InnerRadiusSize: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "InnerRadiusSize" + + @staticmethod + def __call__(self): + radius = self.Radius + innerradius = self.InnerRadius + + assert (not exists(innerradius)) or (radius > innerradius) + + + + +class IfcSweptDiskSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x3_rc3.ifcconic','ifc4x3_rc3.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + +class IfcSweptDiskSolidPolygonal_CorrectRadii: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "CorrectRadii" + + @staticmethod + def __call__(self): + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or (filletradius >= self.Radius) + + + + +class IfcSweptDiskSolidPolygonal_DirectrixIsPolyline: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "DirectrixIsPolyline" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_rc3.ifcpolyline' in typeof(self.Directrix)) or (('ifc4x3_rc3.ifcindexedpolycurve' in typeof(self.Directrix)) and (not exists(self.Directrix.Segments))) + + + + + +class IfcSweptSurface_SweptCurveType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptSurface" + RULE_NAME = "SweptCurveType" + + @staticmethod + def __call__(self): + sweptcurve = self.SweptCurve + + assert sweptcurve.ProfileType == IfcProfileTypeEnum.Curve + + + + + +class IfcSwitchingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSwitchingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcswitchingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSwitchingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSystemFurnitureElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSystemFurnitureElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcsystemfurnitureelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSystemFurnitureElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < depth + + + + +class IfcTShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcTable_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + rows = self.Rows + + assert (sizeof([temp for temp in rows if hiindex(temp.RowCells) != (hiindex(rows[1 - 1].RowCells))])) == 0 + + + + +class IfcTable_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + numberofheadings = self.NumberOfHeadings + + assert 0 <= numberofheadings <= 1 + + + + +def calc_IfcTable_NumberOfCellsInRow(self): + rows = self.Rows + return \ + hiindex(rows[1 - 1].RowCells) + + + +def calc_IfcTable_NumberOfHeadings(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if temp.IsHeading]) + + + +def calc_IfcTable_NumberOfDataRows(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if not temp.IsHeading]) + + + + + + + + + + +class IfcTank_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTank_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifctanktype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTankType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTankType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTask_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTask_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcTaskType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTaskType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + +class IfcTelecomAddress_MinimumDataProvided: + SCOPE = "entity" + TYPE_NAME = "IfcTelecomAddress" + RULE_NAME = "MinimumDataProvided" + + @staticmethod + def __call__(self): + telephonenumbers = self.TelephoneNumbers + facsimilenumbers = self.FacsimileNumbers + pagernumber = self.PagerNumber + electronicmailaddresses = self.ElectronicMailAddresses + wwwhomepageurl = self.WWWHomePageURL + messagingids = self.MessagingIDs + + assert exists(telephonenumbers) or exists(facsimilenumbers) or exists(pagernumber) or exists(electronicmailaddresses) or exists(wwwhomepageurl) or exists(messagingids) + + + + + +class IfcTendon_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendon_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifctendontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonAnchor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifctendonanchortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonConduit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonConduit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifctendonconduittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonConduitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcTessellatedFaceSet_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcTextLiteralWithExtent_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcTextLiteralWithExtent" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + extent = self.Extent + + assert not 'ifc4x3_rc3.ifcplanarbox' in typeof(extent) + + + + + + + + +class IfcTextStyleFontModel_MeasureOfFontSize: + SCOPE = "entity" + TYPE_NAME = "IfcTextStyleFontModel" + RULE_NAME = "MeasureOfFontSize" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_rc3.ifclengthmeasure' in typeof(self.FontSize)) and (self.FontSize > 0.) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTopologyRepresentation_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x3_rc3.ifctopologicalrepresentationitem' in typeof(temp)])) == 0 + + + + +class IfcTopologyRepresentation_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcTopologyRepresentation_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + + + assert IfcTopologyRepresentationTypes(self.RepresentationType,self.Items) + + + + + +class IfcToroidalSurface_MajorLargerMinor: + SCOPE = "entity" + TYPE_NAME = "IfcToroidalSurface" + RULE_NAME = "MajorLargerMinor" + + @staticmethod + def __call__(self): + majorradius = self.MajorRadius + minorradius = self.MinorRadius + + assert minorradius < majorradius + + + + + +class IfcTrackElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTrackElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTrackElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTrackElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifctrackelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTrackElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTrackElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTrackElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTransformer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransformer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifctranformertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransformerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTransportElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or ((predefinedtype != IfcTransportElementFixedTypeEnum.USERDEFINED) and (predefinedtype != IfcTransportElementNonFixedTypeEnum.USERDEFINED)) or (((predefinedtype == IfcTransportElementFixedTypeEnum.USERDEFINED) or (predefinedtype == IfcTransportElementNonFixedTypeEnum.USERDEFINED)) and exists(self.ElementType)) + + + + +class IfcTransportElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifctransportelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransportElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert ((predefinedtype != IfcTransportElementFixedTypeEnum.USERDEFINED) and (predefinedtype != IfcTransportElementNonFixedTypeEnum.USERDEFINED)) or ((predefinedtype == IfcTransportElementFixedTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransportElementNonFixedTypeEnum.USERDEFINED) and exists(self.ElementType))) + + + + + + + + +def calc_IfcTriangulatedFaceSet_NumberOfTriangles(self): + coordindex = self.CoordIndex + return \ + sizeof(coordindex) + + + + +class IfcTriangulatedIrregularNetwork_NotClosed: + SCOPE = "entity" + TYPE_NAME = "IfcTriangulatedIrregularNetwork" + RULE_NAME = "NotClosed" + + @staticmethod + def __call__(self): + + + assert self.Closed == False + + + + + +class IfcTrimmedCurve_Trim1ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim1ValuesConsistent" + + @staticmethod + def __call__(self): + trim1 = self.Trim1 + + assert (hiindex(trim1) == 1) or ((typeof(trim1[1 - 1])) != (typeof(trim1[2 - 1]))) + + + + +class IfcTrimmedCurve_Trim2ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim2ValuesConsistent" + + @staticmethod + def __call__(self): + trim2 = self.Trim2 + + assert (hiindex(trim2) == 1) or ((typeof(trim2[1 - 1])) != (typeof(trim2[2 - 1]))) + + + + +class IfcTrimmedCurve_NoTrimOfBoundedCurves: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "NoTrimOfBoundedCurves" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert not 'ifc4x3_rc3.ifcboundedcurve' in typeof(basiscurve) + + + + + +class IfcTubeBundle_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTubeBundle_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifctubebundletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTubeBundleType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundleType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTypeObject_NameRequired: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "NameRequired" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTypeObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + haspropertysets = self.HasPropertySets + + assert (not exists(haspropertysets)) or IfcUniquePropertySetNames(haspropertysets) + + + + + + + + +class IfcTypeProduct_ApplicableOccurrence: + SCOPE = "entity" + TYPE_NAME = "IfcTypeProduct" + RULE_NAME = "ApplicableOccurrence" + + @staticmethod + def __call__(self): + + + assert (not exists(lambda: self.Types[1 - 1])) or ((sizeof([temp for temp in self.Types[1 - 1].RelatedObjects if not 'ifc4x3_rc3.ifcproduct' in typeof(temp)])) == 0) + + + + + + + + +class IfcUShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + +class IfcUShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcUnitAssignment_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcUnitAssignment" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + units = self.Units + + assert IfcCorrectUnitAssignment(units) + + + + + +class IfcUnitaryControlElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryControlElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcunitarycontrolelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryControlElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcUnitaryEquipment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryEquipment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcunitaryequipmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryEquipmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcValve_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcValve_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcvalvetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcValveType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValveType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVector_MagGreaterOrEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcVector" + RULE_NAME = "MagGreaterOrEqualZero" + + @staticmethod + def __call__(self): + magnitude = self.Magnitude + + assert magnitude >= 0.0 + + + + +def calc_IfcVector_Dim(self): + orientation = self.Orientation + return \ + orientation.Dim + + + + + + + + + + + + + +class IfcVibrationDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcvibrationdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVibrationIsolator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationIsolator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcvibrationisolatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationIsolatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + +class IfcVoidingFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcVoidingFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVoidingFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWallElementedCase_HasDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcWallElementedCase" + RULE_NAME = "HasDecomposition" + + @staticmethod + def __call__(self): + + + assert hiindex(self.IsDecomposedBy) > 0 + + + + + +class IfcWallStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcWallStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc3.ifcrelassociates.relatedobjects') if ('ifc4x3_rc3.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc3.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWasteTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWasteTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcwasteterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWasteTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcWindow_CorrectStyleAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectStyleAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcwindowtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + +class IfcWindow_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWindowTypeEnum.USERDEFINED) or ((predefinedtype == IfcWindowTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWindow_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc3.ifcwindowtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWindowLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcWindowLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + firsttransomoffset = self.FirstTransomOffset + secondtransomoffset = self.SecondTransomOffset + + assert not (not exists(firsttransomoffset)) and exists(secondtransomoffset) + + + + +class IfcWindowLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + firstmullionoffset = self.FirstMullionOffset + secondmullionoffset = self.SecondMullionOffset + + assert not (not exists(firstmullionoffset)) and exists(secondmullionoffset) + + + + +class IfcWindowLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc3.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc3.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcWindowPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc3.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc3.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + + + + + + + +class IfcWindowType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWindowTypeEnum.USERDEFINED) or ((predefinedtype == IfcWindowTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWorkCalendar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkCalendar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkCalendarTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkCalendarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcWorkPlan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkPlan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkPlanTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkPlanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcWorkSchedule_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkSchedule" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkScheduleTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkScheduleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcZShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcZShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + + +class IfcZone_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcZone" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof(self.IsGroupedBy) == 0) or ((sizeof([temp for temp in self.IsGroupedBy[1 - 1].RelatedObjects if not ('ifc4x3_rc3.ifczone' in typeof(temp)) or ('ifc4x3_rc3.ifcspace' in typeof(temp)) or ('ifc4x3_rc3.ifcspatialzone' in typeof(temp))])) == 0) + + + + + +class IfcRepresentationContextSameWCS: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcGeometricRepresentationContext = file.by_type("IfcGeometricRepresentationContext") + isdifferent = False + if sizeof(IfcGeometricRepresentationContext) > 1: + for i in range(2, hiindex(IfcGeometricRepresentationContext) + 1): + if (IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem) != (IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem): + isdifferent = (not IfcSameValidPrecision(IfcGeometricRepresentationContext[1 - 1].Precision,IfcGeometricRepresentationContext[i - 1].Precision)) or (not IfcSameAxis2Placement(IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[1 - 1].Precision)) + if isdifferent == True: + break + + assert isdifferent == False + + + + + +class IfcSingleProjectInstance: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcProject = file.by_type("IfcProject") + + + + assert sizeof(IfcProject) <= 1 + + + + +def IfcAssociatedSurface(arg): + + surf = arg.BasisSurface + return surf + + +def IfcBaseAxis(dim, axis1, axis2, axis3): + + + + if dim == 3: + d1 = nvl(IfcNormalise(axis3),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,axis1) + u = [d2,IfcSecondProjAxis(d1,d2,axis2),d1] + else: + if exists(axis1): + d1 = IfcNormalise(axis1) + u = [d1,IfcOrthogonalComplement(d1)] + if exists(axis2): + factor = IfcDotProduct(axis2,u[2 - 1]) + if factor < 0.0: + u[2 - 1].DirectionRatios[1 - 1] = -u[2 - 1].DirectionRatios[1 - 1] + u[2 - 1].DirectionRatios[2 - 1] = -u[2 - 1].DirectionRatios[2 - 1] + else: + if exists(axis2): + d1 = IfcNormalise(axis2) + u = [IfcOrthogonalComplement(d1),d1] + u[1 - 1].DirectionRatios[1 - 1] = -u[1 - 1].DirectionRatios[1 - 1] + u[1 - 1].DirectionRatios[2 - 1] = -u[1 - 1].DirectionRatios[2 - 1] + else: + u = [IfcDirection(DirectionRatios=[1.0,0.0]),IfcDirection(DirectionRatios=[0.0,1.0])] + return u + + +def IfcBooleanChoose(b, choice1, choice2): + + if b: + return choice1 + else: + return choice2 + + +def IfcBuild2Axes(refdirection): + d = nvl(IfcNormalise(refdirection),IfcDirection(DirectionRatios=[1.0,0.0])) + return [d,IfcOrthogonalComplement(d)] + + +def IfcBuildAxes(axis, refdirection): + + d1 = nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,refdirection) + return [d2,IfcNormalise(IfcCrossProduct(d1,d2)).Orientation,d1] + + +def IfcConsecutiveSegments(segments): + result = True + for i in range(1, hiindex(segments) - 1 + 1): + if (segments[i - 1][hiindex(segments[i - 1]) - 1]) != (segments[i - 1][1 - 1]): + result = False + break + return result + + +def IfcConstraintsParamBSpline(degree, upknots, upcp, knotmult, knots): + result = True + + sum = knotmult[1 - 1] + for i in range(2, upknots + 1): + sum = sum + (knotmult[i - 1]) + if (degree < 1) or (upknots < 2) or (upcp < degree) or (sum != (degree + upcp + 2)): + result = False + return result + k = knotmult[1 - 1] + if (k < 1) or (k > (degree + 1)): + result = False + return result + for i in range(2, upknots + 1): + if ((knotmult[i - 1]) < 1) or ((knots[i - 1]) <= (knots[i - 1])): + result = False + return result + k = knotmult[i - 1] + if (i < upknots) and (k > degree): + result = False + return result + if (i == upknots) and (k > (degree + 1)): + result = False + return result + return result + + +def IfcConvertDirectionInto2D(direction): + direction2d = IfcDirection(DirectionRatios=[0.,1.]) + temp = list(direction2d.DirectionRatios) + temp[1 - 1] = direction.DirectionRatios[1 - 1] + direction2d.DirectionRatios = temp + temp = list(direction2d.DirectionRatios) + temp[2 - 1] = direction.DirectionRatios[2 - 1] + direction2d.DirectionRatios = temp + return direction2d + + +def IfcCorrectDimensions(m, dim): + + if m == lengthunit: + if dim == IfcDimensionalExponents(1,0,0,0,0,0,0): + return True + else: + return False + elif m == massunit: + if dim == IfcDimensionalExponents(0,1,0,0,0,0,0): + return True + else: + return False + elif m == timeunit: + if dim == IfcDimensionalExponents(0,0,1,0,0,0,0): + return True + else: + return False + elif m == electriccurrentunit: + if dim == IfcDimensionalExponents(0,0,0,1,0,0,0): + return True + else: + return False + elif m == thermodynamictemperatureunit: + if dim == IfcDimensionalExponents(0,0,0,0,1,0,0): + return True + else: + return False + elif m == amountofsubstanceunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,1,0): + return True + else: + return False + elif m == luminousintensityunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == planeangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == solidangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == areaunit: + if dim == IfcDimensionalExponents(2,0,0,0,0,0,0): + return True + else: + return False + elif m == volumeunit: + if dim == IfcDimensionalExponents(3,0,0,0,0,0,0): + return True + else: + return False + elif m == absorbeddoseunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == radioactivityunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == electriccapacitanceunit: + if dim == IfcDimensionalExponents(-2,-1,4,2,0,0,0): + return True + else: + return False + elif m == doseequivalentunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == electricchargeunit: + if dim == IfcDimensionalExponents(0,0,1,1,0,0,0): + return True + else: + return False + elif m == electricconductanceunit: + if dim == IfcDimensionalExponents(-2,-1,3,2,0,0,0): + return True + else: + return False + elif m == electricvoltageunit: + if dim == IfcDimensionalExponents(2,1,-3,-1,0,0,0): + return True + else: + return False + elif m == electricresistanceunit: + if dim == IfcDimensionalExponents(2,1,-3,-2,0,0,0): + return True + else: + return False + elif m == energyunit: + if dim == IfcDimensionalExponents(2,1,-2,0,0,0,0): + return True + else: + return False + elif m == forceunit: + if dim == IfcDimensionalExponents(1,1,-2,0,0,0,0): + return True + else: + return False + elif m == frequencyunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == inductanceunit: + if dim == IfcDimensionalExponents(2,1,-2,-2,0,0,0): + return True + else: + return False + elif m == illuminanceunit: + if dim == IfcDimensionalExponents(-2,0,0,0,0,0,1): + return True + else: + return False + elif m == luminousfluxunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == magneticfluxunit: + if dim == IfcDimensionalExponents(2,1,-2,-1,0,0,0): + return True + else: + return False + elif m == magneticfluxdensityunit: + if dim == IfcDimensionalExponents(0,1,-2,-1,0,0,0): + return True + else: + return False + elif m == powerunit: + if dim == IfcDimensionalExponents(2,1,-3,0,0,0,0): + return True + else: + return False + elif m == pressureunit: + if dim == IfcDimensionalExponents(-1,1,-2,0,0,0,0): + return True + else: + return False + else: + return unknown + + +def IfcCorrectFillAreaStyle(styles): + hatching = 0 + tiles = 0 + colour = 0 + external = 0 + external = sizeof([style for style in styles if 'ifc4x3_rc3.ifcexternallydefinedhatchstyle' in typeof(style)]) + hatching = sizeof([style for style in styles if 'ifc4x3_rc3.ifcfillareastylehatching' in typeof(style)]) + tiles = sizeof([style for style in styles if 'ifc4x3_rc3.ifcfillareastyletiles' in typeof(style)]) + colour = sizeof([style for style in styles if 'ifc4x3_rc3.ifccolour' in typeof(style)]) + if external > 1: + return False + if (external == 1) and ((hatching > 0) or (tiles > 0) or (colour > 0)): + return False + if colour > 1: + return False + if (hatching > 0) and (tiles > 0): + return False + return True + + +def IfcCorrectLocalPlacement(axisplacement, relplacement): + + if exists(relplacement): + if 'ifc4x3_rc3.ifcgridplacement' in typeof(relplacement): + return None + if 'ifc4x3_rc3.ifclocalplacement' in typeof(relplacement): + if 'ifc4x3_rc3.ifcaxis2placement2d' in typeof(axisplacement): + return True + if 'ifc4x3_rc3.ifcaxis2placement3d' in typeof(axisplacement): + if relplacement.RelativePlacement.Dim == 3: + return True + else: + return False + return True + return None + + +def IfcCorrectObjectAssignment(constraint, objects): + count = 0 + if not exists(constraint): + return True + if constraint == IfcObjectTypeEnum.NOTDEFINED: + return True + elif constraint == IfcObjectTypeEnum.PRODUCT: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc3.ifcproduct' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROCESS: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc3.ifcprocess' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.CONTROL: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc3.ifccontrol' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.RESOURCE: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc3.ifcresource' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.ACTOR: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc3.ifcactor' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.GROUP: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc3.ifcgroup' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROJECT: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc3.ifcproject' in typeof(temp)]) + return count == 0 + else: + return None + + +def IfcCorrectUnitAssignment(units): + namedunitnumber = 0 + derivedunitnumber = 0 + monetaryunitnumber = 0 + namedunitnames = express_set([]) + derivedunitnames = express_set([]) + namedunitnumber = sizeof([temp for temp in units if ('ifc4x3_rc3.ifcnamedunit' in typeof(temp)) and (not temp.UnitType == IfcUnitEnum.USERDEFINED)]) + derivedunitnumber = sizeof([temp for temp in units if ('ifc4x3_rc3.ifcderivedunit' in typeof(temp)) and (not temp.UnitType == IfcDerivedUnitEnum.USERDEFINED)]) + monetaryunitnumber = sizeof([temp for temp in units if 'ifc4x3_rc3.ifcmonetaryunit' in typeof(temp)]) + for i in range(1, sizeof(units) + 1): + if ('ifc4x3_rc3.ifcnamedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcUnitEnum.USERDEFINED): + namedunitnames = namedunitnames + (units[i - 1].UnitType) + if ('ifc4x3_rc3.ifcderivedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcDerivedUnitEnum.USERDEFINED): + derivedunitnames = derivedunitnames + (units[i - 1].UnitType) + return (sizeof(namedunitnames) == namedunitnumber) and (sizeof(derivedunitnames) == derivedunitnumber) and (monetaryunitnumber <= 1) + + +def IfcCrossProduct(arg1, arg2): + + + + + if ((not exists(arg1)) or (arg1.Dim == 2)) or ((not exists(arg2)) or (arg2.Dim == 2)): + return None + else: + v1 = IfcNormalise(arg1).DirectionRatios + v2 = IfcNormalise(arg2).DirectionRatios + res = IfcDirection(DirectionRatios=[((v1[2 - 1]) * (v2[3 - 1])) - ((v1[3 - 1]) * (v2[2 - 1])),((v1[3 - 1]) * (v2[1 - 1])) - ((v1[1 - 1]) * (v2[3 - 1])),((v1[1 - 1]) * (v2[2 - 1])) - ((v1[2 - 1]) * (v2[1 - 1]))]) + mag = 0.0 + for i in range(1, 3 + 1): + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=arg1, Magnitude=0.0) + return result + + +def IfcCurveDim(curve): + + if 'ifc4x3_rc3.ifcline' in typeof(curve): + return curve.Pnt.Dim + if 'ifc4x3_rc3.ifcconic' in typeof(curve): + return curve.Position.Dim + if 'ifc4x3_rc3.ifcpolyline' in typeof(curve): + return curve.Points[1 - 1].Dim + if 'ifc4x3_rc3.ifctrimmedcurve' in typeof(curve): + return IfcCurveDim(curve.BasisCurve) + if 'ifc4x3_rc3.ifcgradientcurve' in typeof(curve): + return 3 + if 'ifc4x3_rc3.ifcsegmentedreferencecurve' in typeof(curve): + return 3 + if 'ifc4x3_rc3.ifccompositecurve' in typeof(curve): + return curve.Segments[1 - 1].Dim + if 'ifc4x3_rc3.ifcbsplinecurve' in typeof(curve): + return curve.ControlPointsList[1 - 1].Dim + if 'ifc4x3_rc3.ifcoffsetcurve2d' in typeof(curve): + return 2 + if 'ifc4x3_rc3.ifcoffsetcurve3d' in typeof(curve): + return 3 + if 'ifc4x3_rc3.ifcoffsetcurvebydistances' in typeof(curve): + return 3 + if 'ifc4x3_rc3.ifccurvesegment2d' in typeof(curve): + return 2 + if 'ifc4x3_rc3.ifcpolynomialcurve' in typeof(curve): + if (not exists(curve.CoefficientsZ)) and (curve.Position.Dim == 2): + return 2 + return 3 + if 'ifc4x3_rc3.ifcpcurve' in typeof(curve): + return 3 + if 'ifc4x3_rc3.ifcindexedpolycurve' in typeof(curve): + return curve.Points.Dim + return None + + +def IfcCurveWeightsPositive(b): + result = True + for i in range(0, b.UpperIndexOnControlPoints + 1): + if (b.Weights[i - 1]) <= 0.0: + result = False + return result + return result + + +def IfcDeriveDimensionalExponents(unitelements): + result = IfcDimensionalExponents(0,0,0,0,0,0,0) + for i in range(loindex(unitelements), hiindex(unitelements) + 1): + result.LengthExponent = result.LengthExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LengthExponent)) + result.MassExponent = result.MassExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.MassExponent)) + result.TimeExponent = result.TimeExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.TimeExponent)) + result.ElectricCurrentExponent = result.ElectricCurrentExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ElectricCurrentExponent)) + result.ThermodynamicTemperatureExponent = result.ThermodynamicTemperatureExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ThermodynamicTemperatureExponent)) + result.AmountOfSubstanceExponent = result.AmountOfSubstanceExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.AmountOfSubstanceExponent)) + result.LuminousIntensityExponent = result.LuminousIntensityExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LuminousIntensityExponent)) + return result + + +def IfcDimensionsForSiUnit(n): + + if n == metre: + return IfcDimensionalExponents(1,0,0,0,0,0,0) + elif n == square_metre: + return IfcDimensionalExponents(2,0,0,0,0,0,0) + elif n == cubic_metre: + return IfcDimensionalExponents(3,0,0,0,0,0,0) + elif n == gram: + return IfcDimensionalExponents(0,1,0,0,0,0,0) + elif n == second: + return IfcDimensionalExponents(0,0,1,0,0,0,0) + elif n == ampere: + return IfcDimensionalExponents(0,0,0,1,0,0,0) + elif n == kelvin: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == mole: + return IfcDimensionalExponents(0,0,0,0,0,1,0) + elif n == candela: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == radian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == steradian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == hertz: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == newton: + return IfcDimensionalExponents(1,1,-2,0,0,0,0) + elif n == pascal: + return IfcDimensionalExponents(-1,1,-2,0,0,0,0) + elif n == joule: + return IfcDimensionalExponents(2,1,-2,0,0,0,0) + elif n == watt: + return IfcDimensionalExponents(2,1,-3,0,0,0,0) + elif n == coulomb: + return IfcDimensionalExponents(0,0,1,1,0,0,0) + elif n == volt: + return IfcDimensionalExponents(2,1,-3,-1,0,0,0) + elif n == farad: + return IfcDimensionalExponents(-2,-1,4,2,0,0,0) + elif n == ohm: + return IfcDimensionalExponents(2,1,-3,-2,0,0,0) + elif n == siemens: + return IfcDimensionalExponents(-2,-1,3,2,0,0,0) + elif n == weber: + return IfcDimensionalExponents(2,1,-2,-1,0,0,0) + elif n == tesla: + return IfcDimensionalExponents(0,1,-2,-1,0,0,0) + elif n == henry: + return IfcDimensionalExponents(2,1,-2,-2,0,0,0) + elif n == degree_celsius: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == lumen: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == lux: + return IfcDimensionalExponents(-2,0,0,0,0,0,1) + elif n == becquerel: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == gray: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + elif n == sievert: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + else: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + + +def IfcDotProduct(arg1, arg2): + + + + if (not exists(arg1)) or (not exists(arg2)): + scalar = None + else: + if arg1.Dim != arg2.Dim: + scalar = None + else: + vec1 = IfcNormalise(arg1) + vec2 = IfcNormalise(arg2) + ndim = arg1.Dim + scalar = 0.0 + for i in range(1, ndim + 1): + scalar = scalar + ((vec1.DirectionRatios[i - 1]) * (vec2.DirectionRatios[i - 1])) + return scalar + + +def IfcFirstProjAxis(zaxis, arg): + + + + + if not exists(zaxis): + return None + else: + z = IfcNormalise(zaxis) + if not exists(arg): + if z.DirectionRatios != [1.0,0.0,0.0]: + v = IfcDirection(DirectionRatios=[1.0,0.0,0.0]) + else: + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + if arg.Dim != 3: + return None + if IfcCrossProduct(arg,z).Magnitude == 0.0: + return None + else: + v = IfcNormalise(arg) + xvec = IfcScalarTimesVector(IfcDotProduct(v,z),z) + xaxis = IfcVectorDifference(v,xvec).Orientation + xaxis = IfcNormalise(xaxis) + return xaxis + + +def IfcGetBasisSurface(c): + + + surfs = [] + if 'ifc4x3_rc3.ifcpcurve' in typeof(c): + surfs = [c.BasisSurface] + else: + if 'ifc4x3_rc3.ifcsurfacecurve' in typeof(c): + n = sizeof(c.AssociatedGeometry) + for i in range(1, n + 1): + surfs = surfs + (IfcAssociatedSurface(c.AssociatedGeometry[i - 1])) + if 'ifc4x3_rc3.ifccompositecurveonsurface' in typeof(c): + n = sizeof(c.Segments) + surfs = IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve) + if n > 1: + for i in range(2, n + 1): + surfs = surfs * (IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve)) + return surfs + + +def IfcGradient(gradientcurve): + + return 1 + + +def IfcListToArray(lis, low, u): + + + n = sizeof(lis) + if n != (u - low + 1): + return None + else: + res = ([lis[1 - 1]] * n) + for i in range(2, n + 1): + temp = list(res) + temp[low - 1] = lis[i - 1] + res = temp + return res + + +def IfcLoopHeadToTail(aloop): + + p = True + n = sizeof(aloop.EdgeList) + for i in range(2, n + 1): + p = p and ((aloop.EdgeList[i - 1].EdgeEnd) == (aloop.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcMakeArrayOfArray(lis, low1, u1, low2, u2): + + if (u1 - low1 + 1) != sizeof(lis): + return None + if (u2 - low2 + 1) != (sizeof(lis[1 - 1])): + return None + res = ([IfcListToArray(lis[1 - 1],low2,u2)] * u1 - low1 + 1) + for i in range(2, hiindex(lis) + 1): + if (u2 - low2 + 1) != (sizeof(lis[i - 1])): + return None + temp = list(res) + temp[low1 - 1] = IfcListToArray(lis[i - 1],low2,u2) + res = temp + return res + + +def IfcMlsTotalThickness(layerset): + max = layerset.MaterialLayers[1 - 1].LayerThickness + if sizeof(layerset.MaterialLayers) > 1: + for i in range(2, hiindex(layerset.MaterialLayers) + 1): + max = max + (layerset.MaterialLayers[i - 1].LayerThickness) + return max + + +def IfcNormalise(arg): + + v = IfcDirection(DirectionRatios=[1.,0.]) + vec = IfcVector(Orientation=IfcDirection(DirectionRatios=[1.,0.]), Magnitude=1.) + + result = v + if not exists(arg): + return None + else: + if 'ifc4x3_rc3.ifcvector' in typeof(arg): + ndim = arg.Dim + v.DirectionRatios = arg.Orientation.DirectionRatios + vec.Magnitude = arg.Magnitude + vec.Orientation = v + if arg.Magnitude == 0.0: + return None + else: + vec.Magnitude = 1.0 + else: + ndim = arg.Dim + v.DirectionRatios = arg.DirectionRatios + mag = 0.0 + for i in range(1, ndim + 1): + mag = mag + ((v.DirectionRatios[i - 1]) * (v.DirectionRatios[i - 1])) + if mag > 0.0: + mag = sqrt(mag) + for i in range(1, ndim + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = (v.DirectionRatios[i - 1]) / mag + v.DirectionRatios = temp + if 'ifc4x3_rc3.ifcvector' in typeof(arg): + vec.Orientation = v + result = vec + else: + result = v + else: + return None + return result + + +def IfcOrthogonalComplement(vec): + + if (not exists(vec)) or (vec.Dim != 2): + return None + else: + result = IfcDirection(DirectionRatios=[-vec.DirectionRatios[2 - 1],vec.DirectionRatios[1 - 1]]) + return result + + +def IfcPathHeadToTail(apath): + n = 0 + p = unknown + n = sizeof(apath.EdgeList) + for i in range(2, n + 1): + p = p and ((apath.EdgeList[i - 1].EdgeEnd) == (apath.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcPointListDim(pointlist): + + if 'ifc4x3_rc3.ifccartesianpointlist2d' in typeof(pointlist): + return 2 + if 'ifc4x3_rc3.ifccartesianpointlist3d' in typeof(pointlist): + return 3 + return None + + +def IfcSameAxis2Placement(ap1, ap2, epsilon): + + return (IfcSameDirection(ap1.P[1 - 1],ap2.P[1 - 1],epsilon)) and (IfcSameDirection(ap1.P[2 - 1],ap2.P[2 - 1],epsilon)) and IfcSameCartesianPoint(ap1.Location,ap1.Location,epsilon) + + +def IfcSameCartesianPoint(cp1, cp2, epsilon): + cp1x = cp1.Coordinates[1 - 1] + cp1y = cp1.Coordinates[2 - 1] + cp1z = 0 + cp2x = cp2.Coordinates[1 - 1] + cp2y = cp2.Coordinates[2 - 1] + cp2z = 0 + if sizeof(cp1.Coordinates) > 2: + cp1z = cp1.Coordinates[3 - 1] + if sizeof(cp2.Coordinates) > 2: + cp2z = cp2.Coordinates[3 - 1] + return IfcSameValue(cp1x,cp2x,epsilon) and IfcSameValue(cp1y,cp2y,epsilon) and IfcSameValue(cp1z,cp2z,epsilon) + + +def IfcSameDirection(dir1, dir2, epsilon): + dir1x = dir1.DirectionRatios[1 - 1] + dir1y = dir1.DirectionRatios[2 - 1] + dir1z = 0 + dir2x = dir2.DirectionRatios[1 - 1] + dir2y = dir2.DirectionRatios[2 - 1] + dir2z = 0 + if sizeof(dir1.DirectionRatios) > 2: + dir1z = dir1.DirectionRatios[3 - 1] + if sizeof(dir2.DirectionRatios) > 2: + dir2z = dir2.DirectionRatios[3 - 1] + return IfcSameValue(dir1x,dir2x,epsilon) and IfcSameValue(dir1y,dir2y,epsilon) and IfcSameValue(dir1z,dir2z,epsilon) + + +def IfcSameValidPrecision(epsilon1, epsilon2): + + defaulteps = 0.000001 + derivationofeps = 1.001 + uppereps = 1.0 + valideps1 = nvl(epsilon1,defaulteps) + valideps2 = nvl(epsilon2,defaulteps) + return (0.0 < valideps1) and (valideps1 <= (derivationofeps * valideps2)) and (valideps2 <= (derivationofeps * valideps1)) and (valideps2 < uppereps) + + +def IfcSameValue(value1, value2, epsilon): + + defaulteps = 0.000001 + valideps = nvl(epsilon,defaulteps) + return ((value1 + valideps) > value2) and (value1 < (value2 + valideps)) + + +def IfcScalarTimesVector(scalar, vec): + + + + if (not exists(scalar)) or (not exists(vec)): + return None + else: + if 'ifc4x3_rc3.ifcvector' in typeof(vec): + v = vec.Orientation + mag = scalar * vec.Magnitude + else: + v = vec + mag = scalar + if mag < 0.0: + for i in range(1, sizeof(v.DirectionRatios) + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = -v.DirectionRatios[i - 1] + v.DirectionRatios = temp + mag = -mag + result = IfcVector(Orientation=IfcNormalise(v), Magnitude=mag) + return result + + +def IfcSecondProjAxis(zaxis, xaxis, arg): + + + + if not exists(arg): + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + v = arg + temp = IfcScalarTimesVector(IfcDotProduct(v,zaxis),zaxis) + yaxis = IfcVectorDifference(v,temp) + temp = IfcScalarTimesVector(IfcDotProduct(v,xaxis),xaxis) + yaxis = IfcVectorDifference(yaxis,temp) + yaxis = IfcNormalise(yaxis) + return yaxis.Orientation + + +def IfcShapeRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'point': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifcpoint' in typeof(temp)]) + elif reptype.lower() == 'pointcloud': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifccartesianpointlist3d' in typeof(temp)]) + elif reptype.lower() == 'curve': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifccurve' in typeof(temp)]) + elif reptype.lower() == 'curve2d': + count = sizeof([temp for temp in items if ('ifc4x3_rc3.ifccurve' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'curve3d': + count = sizeof([temp for temp in items if ('ifc4x3_rc3.ifccurve' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'surface': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifcsurface' in typeof(temp)]) + elif reptype.lower() == 'surface2d': + count = sizeof([temp for temp in items if ('ifc4x3_rc3.ifcsurface' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'surface3d': + count = sizeof([temp for temp in items if ('ifc4x3_rc3.ifcsurface' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'fillarea': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifcannotationfillarea' in typeof(temp)]) + elif reptype.lower() == 'text': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifctextliteral' in typeof(temp)]) + elif reptype.lower() == 'advancedsurface': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifcbsplinesurface' in typeof(temp)]) + elif reptype.lower() == 'annotation2d': + count = sizeof([temp for temp in items if (sizeof(typeof(temp) * ['ifc4x3_rc3.ifcpoint','ifc4x3_rc3.ifccurve','ifc4x3_rc3.ifcgeometriccurveset','ifc4x3_rc3.ifcannotationfillarea','ifc4x3_rc3.ifctextliteral'])) == 1]) + elif reptype.lower() == 'geometricset': + count = sizeof([temp for temp in items if ('ifc4x3_rc3.ifcgeometricset' in typeof(temp)) or ('ifc4x3_rc3.ifcpoint' in typeof(temp)) or ('ifc4x3_rc3.ifccurve' in typeof(temp)) or ('ifc4x3_rc3.ifcsurface' in typeof(temp))]) + elif reptype.lower() == 'geometriccurveset': + count = sizeof([temp for temp in items if ('ifc4x3_rc3.ifcgeometriccurveset' in typeof(temp)) or ('ifc4x3_rc3.ifcgeometricset' in typeof(temp)) or ('ifc4x3_rc3.ifcpoint' in typeof(temp)) or ('ifc4x3_rc3.ifccurve' in typeof(temp))]) + for i in range(1, hiindex(items) + 1): + if 'ifc4x3_rc3.ifcgeometricset' in (typeof(items[i - 1])): + if (sizeof([temp for temp in items[i - 1].Elements if 'ifc4x3_rc3.ifcsurface' in typeof(temp)])) > 0: + count = count - 1 + elif reptype.lower() == 'tessellation': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifctessellateditem' in typeof(temp)]) + elif reptype.lower() == 'surfaceorsolidmodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc3.ifctessellateditem','ifc4x3_rc3.ifcshellbasedsurfacemodel','ifc4x3_rc3.ifcfacebasedsurfacemodel','ifc4x3_rc3.ifcsolidmodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'surfacemodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc3.ifctessellateditem','ifc4x3_rc3.ifcshellbasedsurfacemodel','ifc4x3_rc3.ifcfacebasedsurfacemodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'solidmodel': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifcsolidmodel' in typeof(temp)]) + elif reptype.lower() == 'sweptsolid': + count = sizeof([temp for temp in items if ((sizeof(['ifc4x3_rc3.ifcextrudedareasolid','ifc4x3_rc3.ifcrevolvedareasolid'] * typeof(temp))) >= 1) and ((sizeof(['ifc4x3_rc3.ifcextrudedareasolidtapered','ifc4x3_rc3.ifcrevolvedareasolidtapered'] * typeof(temp))) == 0)]) + elif reptype.lower() == 'advancedsweptsolid': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc3.ifcsweptareasolid','ifc4x3_rc3.ifcsweptdisksolid','ifc4x3_rc3.ifcsectionedsolidhorizontal'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'csg': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc3.ifcbooleanresult','ifc4x3_rc3.ifccsgprimitive3d','ifc4x3_rc3.ifccsgsolid'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'clipping': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc3.ifccsgsolid','ifc4x3_rc3.ifcbooleanclippingresult'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'brep': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifcfacetedbrep' in typeof(temp)]) + elif reptype.lower() == 'advancedbrep': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifcmanifoldsolidbrep' in typeof(temp)]) + elif reptype.lower() == 'boundingbox': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifcboundingbox' in typeof(temp)]) + if sizeof(items) > 1: + count = 0 + elif reptype.lower() == 'sectionedspine': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifcsectionedspine' in typeof(temp)]) + elif reptype.lower() == 'lightsource': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifclightsource' in typeof(temp)]) + elif reptype.lower() == 'mappedrepresentation': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifcmappeditem' in typeof(temp)]) + else: + return None + return count == sizeof(items) + + +def IfcSurfaceWeightsPositive(b): + result = True + weights = b.Weights + for i in range(0, b.UUpper + 1): + for j in range(0, b.VUpper + 1): + if (weights[i - 1][j - 1]) <= 0.0: + result = False + return result + return result + + +def IfcTaperedSweptAreaProfiles(startarea, endarea): + result = False + if 'ifc4x3_rc3.ifcparameterizedprofiledef' in typeof(startarea): + if 'ifc4x3_rc3.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = typeof(startarea) == typeof(endarea) + else: + if 'ifc4x3_rc3.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = False + return result + + +def IfcTopologyRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'vertex': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifcvertex' in typeof(temp)]) + elif reptype.lower() == 'edge': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifcedge' in typeof(temp)]) + elif reptype.lower() == 'path': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifcpath' in typeof(temp)]) + elif reptype.lower() == 'face': + count = sizeof([temp for temp in items if 'ifc4x3_rc3.ifcface' in typeof(temp)]) + elif reptype.lower() == 'shell': + count = sizeof([temp for temp in items if ('ifc4x3_rc3.ifcopenshell' in typeof(temp)) or ('ifc4x3_rc3.ifcclosedshell' in typeof(temp))]) + elif reptype.lower() == 'undefined': + return True + else: + return None + return count == sizeof(items) + + +def IfcUniqueDefinitionNames(relations): + + + properties = express_set([]) + + if sizeof(relations) == 0: + return True + for i in range(1, hiindex(relations) + 1): + definition = relations[i - 1].RelatingPropertyDefinition + if 'ifc4x3_rc3.ifcpropertysetdefinition' in typeof(definition): + properties = properties + definition + else: + if 'ifc4x3_rc3.ifcpropertysetdefinitionset' in typeof(definition): + definitionset = definition + for j in range(1, hiindex(definitionset) + 1): + properties = properties + (definitionset[j - 1]) + result = IfcUniquePropertySetNames(properties) + return result + + +def IfcUniquePropertyName(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniquePropertySetNames(properties): + names = express_set([]) + unnamed = 0 + for i in range(1, hiindex(properties) + 1): + if 'ifc4x3_rc3.ifcpropertyset' in (typeof(properties[i - 1])): + names = names + (properties[i - 1].Name) + else: + unnamed = unnamed + 1 + return (sizeof(names) + unnamed) == sizeof(properties) + + +def IfcUniquePropertyTemplateNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniqueQuantityNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcVectorDifference(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x3_rc3.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x3_rc3.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) - (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + +def IfcVectorSum(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x3_rc3.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x3_rc3.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) + (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + diff --git a/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_RC4.py b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_RC4.py new file mode 100644 index 0000000000..461bd07531 --- /dev/null +++ b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_RC4.py @@ -0,0 +1,25103 @@ +import ifcopenshell + +def exists(v): + if callable(v): + try: return v() is not None + except IndexError as e: return False + else: return v is not None + + + +def nvl(v, default): return v if v is not None else default + + +sizeof = len +hiindex = len +blength = len +loindex = lambda x: 1 +from math import * +unknown = 'UNKNOWN' + +def usedin(inst, ref_name): + if inst is None: + return [] + _, __, attr = ref_name.split('.') + def filter(): + for ref, attr_idx in inst.wrapped_data.file.get_inverse(inst, allow_duplicate=True, with_attribute_indices=True): + if ref.wrapped_data.get_attribute_names()[attr_idx].lower() == attr: + yield ref + return list(filter()) + + +class express_set(set): + def __rmul__(self, other): + return express_set(set(other) & self) + def __add__(self, other): + def make_list(v): + # Comply with 12.6.3 Union operator + if isinstance(v, (list, tuple, set, express_set)): + return list(v) + else: + return [v] + return express_set(list(self) + make_list(other)) + __radd__ = __add__ + def __repr__(self): + return repr(set(self)) + + +def typeof(inst): + if not inst: + # If V evaluates to indeterminate (?), an empty set is returned. + return express_set([]) + schema_name = inst.is_a(True).split('.')[0].lower() + def inner(): + decl = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(inst.is_a()) + while decl: + yield '.'.join((schema_name, decl.name().lower())) + decl = decl.supertype() + return express_set(inner()) + +class enum_namespace: + def __getattr__(self, k): + return k.upper() + + +IfcActionRequestTypeEnum = enum_namespace() + + +email = IfcActionRequestTypeEnum.EMAIL + + +fax = IfcActionRequestTypeEnum.FAX + + +phone = IfcActionRequestTypeEnum.PHONE + + +post = IfcActionRequestTypeEnum.POST + + +verbal = IfcActionRequestTypeEnum.VERBAL + + +userdefined = IfcActionRequestTypeEnum.USERDEFINED + + +notdefined = IfcActionRequestTypeEnum.NOTDEFINED + + +IfcActionSourceTypeEnum = enum_namespace() + + +dead_load_g = IfcActionSourceTypeEnum.DEAD_LOAD_G + + +completion_g1 = IfcActionSourceTypeEnum.COMPLETION_G1 + + +live_load_q = IfcActionSourceTypeEnum.LIVE_LOAD_Q + + +snow_s = IfcActionSourceTypeEnum.SNOW_S + + +wind_w = IfcActionSourceTypeEnum.WIND_W + + +prestressing_p = IfcActionSourceTypeEnum.PRESTRESSING_P + + +settlement_u = IfcActionSourceTypeEnum.SETTLEMENT_U + + +temperature_t = IfcActionSourceTypeEnum.TEMPERATURE_T + + +earthquake_e = IfcActionSourceTypeEnum.EARTHQUAKE_E + + +fire = IfcActionSourceTypeEnum.FIRE + + +impulse = IfcActionSourceTypeEnum.IMPULSE + + +impact = IfcActionSourceTypeEnum.IMPACT + + +transport = IfcActionSourceTypeEnum.TRANSPORT + + +erection = IfcActionSourceTypeEnum.ERECTION + + +propping = IfcActionSourceTypeEnum.PROPPING + + +system_imperfection = IfcActionSourceTypeEnum.SYSTEM_IMPERFECTION + + +shrinkage = IfcActionSourceTypeEnum.SHRINKAGE + + +creep = IfcActionSourceTypeEnum.CREEP + + +lack_of_fit = IfcActionSourceTypeEnum.LACK_OF_FIT + + +buoyancy = IfcActionSourceTypeEnum.BUOYANCY + + +ice = IfcActionSourceTypeEnum.ICE + + +current = IfcActionSourceTypeEnum.CURRENT + + +wave = IfcActionSourceTypeEnum.WAVE + + +rain = IfcActionSourceTypeEnum.RAIN + + +brakes = IfcActionSourceTypeEnum.BRAKES + + +userdefined = IfcActionSourceTypeEnum.USERDEFINED + + +notdefined = IfcActionSourceTypeEnum.NOTDEFINED + + +IfcActionTypeEnum = enum_namespace() + + +permanent_g = IfcActionTypeEnum.PERMANENT_G + + +variable_q = IfcActionTypeEnum.VARIABLE_Q + + +extraordinary_a = IfcActionTypeEnum.EXTRAORDINARY_A + + +userdefined = IfcActionTypeEnum.USERDEFINED + + +notdefined = IfcActionTypeEnum.NOTDEFINED + + +IfcActuatorTypeEnum = enum_namespace() + + +electricactuator = IfcActuatorTypeEnum.ELECTRICACTUATOR + + +handoperatedactuator = IfcActuatorTypeEnum.HANDOPERATEDACTUATOR + + +hydraulicactuator = IfcActuatorTypeEnum.HYDRAULICACTUATOR + + +pneumaticactuator = IfcActuatorTypeEnum.PNEUMATICACTUATOR + + +thermostaticactuator = IfcActuatorTypeEnum.THERMOSTATICACTUATOR + + +userdefined = IfcActuatorTypeEnum.USERDEFINED + + +notdefined = IfcActuatorTypeEnum.NOTDEFINED + + +IfcAddressTypeEnum = enum_namespace() + + +office = IfcAddressTypeEnum.OFFICE + + +site = IfcAddressTypeEnum.SITE + + +home = IfcAddressTypeEnum.HOME + + +distributionpoint = IfcAddressTypeEnum.DISTRIBUTIONPOINT + + +userdefined = IfcAddressTypeEnum.USERDEFINED + + +IfcAirTerminalBoxTypeEnum = enum_namespace() + + +constantflow = IfcAirTerminalBoxTypeEnum.CONSTANTFLOW + + +variableflowpressuredependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREDEPENDANT + + +variableflowpressureindependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREINDEPENDANT + + +userdefined = IfcAirTerminalBoxTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalBoxTypeEnum.NOTDEFINED + + +IfcAirTerminalTypeEnum = enum_namespace() + + +diffuser = IfcAirTerminalTypeEnum.DIFFUSER + + +grille = IfcAirTerminalTypeEnum.GRILLE + + +louvre = IfcAirTerminalTypeEnum.LOUVRE + + +register = IfcAirTerminalTypeEnum.REGISTER + + +userdefined = IfcAirTerminalTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalTypeEnum.NOTDEFINED + + +IfcAirToAirHeatRecoveryTypeEnum = enum_namespace() + + +fixedplatecounterflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECOUNTERFLOWEXCHANGER + + +fixedplatecrossflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECROSSFLOWEXCHANGER + + +fixedplateparallelflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATEPARALLELFLOWEXCHANGER + + +rotarywheel = IfcAirToAirHeatRecoveryTypeEnum.ROTARYWHEEL + + +runaroundcoilloop = IfcAirToAirHeatRecoveryTypeEnum.RUNAROUNDCOILLOOP + + +heatpipe = IfcAirToAirHeatRecoveryTypeEnum.HEATPIPE + + +twintowerenthalpyrecoveryloops = IfcAirToAirHeatRecoveryTypeEnum.TWINTOWERENTHALPYRECOVERYLOOPS + + +thermosiphonsealedtubeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONSEALEDTUBEHEATEXCHANGERS + + +thermosiphoncoiltypeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONCOILTYPEHEATEXCHANGERS + + +userdefined = IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED + + +notdefined = IfcAirToAirHeatRecoveryTypeEnum.NOTDEFINED + + +IfcAlarmTypeEnum = enum_namespace() + + +bell = IfcAlarmTypeEnum.BELL + + +breakglassbutton = IfcAlarmTypeEnum.BREAKGLASSBUTTON + + +light = IfcAlarmTypeEnum.LIGHT + + +manualpullbox = IfcAlarmTypeEnum.MANUALPULLBOX + + +siren = IfcAlarmTypeEnum.SIREN + + +whistle = IfcAlarmTypeEnum.WHISTLE + + +railwaycrocodile = IfcAlarmTypeEnum.RAILWAYCROCODILE + + +railwaydetonator = IfcAlarmTypeEnum.RAILWAYDETONATOR + + +userdefined = IfcAlarmTypeEnum.USERDEFINED + + +notdefined = IfcAlarmTypeEnum.NOTDEFINED + + +IfcAlignmentCantSegmentTypeEnum = enum_namespace() + + +blosscurve = IfcAlignmentCantSegmentTypeEnum.BLOSSCURVE + + +constantcant = IfcAlignmentCantSegmentTypeEnum.CONSTANTCANT + + +cosinecurve = IfcAlignmentCantSegmentTypeEnum.COSINECURVE + + +helmertcurve = IfcAlignmentCantSegmentTypeEnum.HELMERTCURVE + + +lineartransition = IfcAlignmentCantSegmentTypeEnum.LINEARTRANSITION + + +sinecurve = IfcAlignmentCantSegmentTypeEnum.SINECURVE + + +viennesebend = IfcAlignmentCantSegmentTypeEnum.VIENNESEBEND + + +IfcAlignmentHorizontalSegmentTypeEnum = enum_namespace() + + +line = IfcAlignmentHorizontalSegmentTypeEnum.LINE + + +circulararc = IfcAlignmentHorizontalSegmentTypeEnum.CIRCULARARC + + +clothoid = IfcAlignmentHorizontalSegmentTypeEnum.CLOTHOID + + +cubic = IfcAlignmentHorizontalSegmentTypeEnum.CUBIC + + +helmertcurve = IfcAlignmentHorizontalSegmentTypeEnum.HELMERTCURVE + + +blosscurve = IfcAlignmentHorizontalSegmentTypeEnum.BLOSSCURVE + + +cosinecurve = IfcAlignmentHorizontalSegmentTypeEnum.COSINECURVE + + +sinecurve = IfcAlignmentHorizontalSegmentTypeEnum.SINECURVE + + +viennesebend = IfcAlignmentHorizontalSegmentTypeEnum.VIENNESEBEND + + +IfcAlignmentTypeEnum = enum_namespace() + + +userdefined = IfcAlignmentTypeEnum.USERDEFINED + + +notdefined = IfcAlignmentTypeEnum.NOTDEFINED + + +IfcAlignmentVerticalSegmentTypeEnum = enum_namespace() + + +constantgradient = IfcAlignmentVerticalSegmentTypeEnum.CONSTANTGRADIENT + + +circulararc = IfcAlignmentVerticalSegmentTypeEnum.CIRCULARARC + + +parabolicarc = IfcAlignmentVerticalSegmentTypeEnum.PARABOLICARC + + +clothoid = IfcAlignmentVerticalSegmentTypeEnum.CLOTHOID + + +IfcAnalysisModelTypeEnum = enum_namespace() + + +in_plane_loading_2d = IfcAnalysisModelTypeEnum.IN_PLANE_LOADING_2D + + +out_plane_loading_2d = IfcAnalysisModelTypeEnum.OUT_PLANE_LOADING_2D + + +loading_3d = IfcAnalysisModelTypeEnum.LOADING_3D + + +userdefined = IfcAnalysisModelTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisModelTypeEnum.NOTDEFINED + + +IfcAnalysisTheoryTypeEnum = enum_namespace() + + +first_order_theory = IfcAnalysisTheoryTypeEnum.FIRST_ORDER_THEORY + + +second_order_theory = IfcAnalysisTheoryTypeEnum.SECOND_ORDER_THEORY + + +third_order_theory = IfcAnalysisTheoryTypeEnum.THIRD_ORDER_THEORY + + +full_nonlinear_theory = IfcAnalysisTheoryTypeEnum.FULL_NONLINEAR_THEORY + + +userdefined = IfcAnalysisTheoryTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisTheoryTypeEnum.NOTDEFINED + + +IfcAnnotationTypeEnum = enum_namespace() + + +assumedpoint = IfcAnnotationTypeEnum.ASSUMEDPOINT + + +asbuiltarea = IfcAnnotationTypeEnum.ASBUILTAREA + + +asbuiltline = IfcAnnotationTypeEnum.ASBUILTLINE + + +non_physical_signal = IfcAnnotationTypeEnum.NON_PHYSICAL_SIGNAL + + +assumedline = IfcAnnotationTypeEnum.ASSUMEDLINE + + +widthevent = IfcAnnotationTypeEnum.WIDTHEVENT + + +assumedarea = IfcAnnotationTypeEnum.ASSUMEDAREA + + +superelevationevent = IfcAnnotationTypeEnum.SUPERELEVATIONEVENT + + +asbuiltpoint = IfcAnnotationTypeEnum.ASBUILTPOINT + + +userdefined = IfcAnnotationTypeEnum.USERDEFINED + + +notdefined = IfcAnnotationTypeEnum.NOTDEFINED + + +IfcArithmeticOperatorEnum = enum_namespace() + + +add = IfcArithmeticOperatorEnum.ADD + + +divide = IfcArithmeticOperatorEnum.DIVIDE + + +multiply = IfcArithmeticOperatorEnum.MULTIPLY + + +subtract = IfcArithmeticOperatorEnum.SUBTRACT + + +IfcAssemblyPlaceEnum = enum_namespace() + + +site = IfcAssemblyPlaceEnum.SITE + + +factory = IfcAssemblyPlaceEnum.FACTORY + + +notdefined = IfcAssemblyPlaceEnum.NOTDEFINED + + +IfcAudioVisualApplianceTypeEnum = enum_namespace() + + +amplifier = IfcAudioVisualApplianceTypeEnum.AMPLIFIER + + +camera = IfcAudioVisualApplianceTypeEnum.CAMERA + + +display = IfcAudioVisualApplianceTypeEnum.DISPLAY + + +microphone = IfcAudioVisualApplianceTypeEnum.MICROPHONE + + +player = IfcAudioVisualApplianceTypeEnum.PLAYER + + +projector = IfcAudioVisualApplianceTypeEnum.PROJECTOR + + +receiver = IfcAudioVisualApplianceTypeEnum.RECEIVER + + +speaker = IfcAudioVisualApplianceTypeEnum.SPEAKER + + +switcher = IfcAudioVisualApplianceTypeEnum.SWITCHER + + +telephone = IfcAudioVisualApplianceTypeEnum.TELEPHONE + + +tuner = IfcAudioVisualApplianceTypeEnum.TUNER + + +communicationterminal = IfcAudioVisualApplianceTypeEnum.COMMUNICATIONTERMINAL + + +recordingequipment = IfcAudioVisualApplianceTypeEnum.RECORDINGEQUIPMENT + + +userdefined = IfcAudioVisualApplianceTypeEnum.USERDEFINED + + +notdefined = IfcAudioVisualApplianceTypeEnum.NOTDEFINED + + +IfcBSplineCurveForm = enum_namespace() + + +polyline_form = IfcBSplineCurveForm.POLYLINE_FORM + + +circular_arc = IfcBSplineCurveForm.CIRCULAR_ARC + + +elliptic_arc = IfcBSplineCurveForm.ELLIPTIC_ARC + + +parabolic_arc = IfcBSplineCurveForm.PARABOLIC_ARC + + +hyperbolic_arc = IfcBSplineCurveForm.HYPERBOLIC_ARC + + +unspecified = IfcBSplineCurveForm.UNSPECIFIED + + +IfcBSplineSurfaceForm = enum_namespace() + + +plane_surf = IfcBSplineSurfaceForm.PLANE_SURF + + +cylindrical_surf = IfcBSplineSurfaceForm.CYLINDRICAL_SURF + + +conical_surf = IfcBSplineSurfaceForm.CONICAL_SURF + + +spherical_surf = IfcBSplineSurfaceForm.SPHERICAL_SURF + + +toroidal_surf = IfcBSplineSurfaceForm.TOROIDAL_SURF + + +surf_of_revolution = IfcBSplineSurfaceForm.SURF_OF_REVOLUTION + + +ruled_surf = IfcBSplineSurfaceForm.RULED_SURF + + +generalised_cone = IfcBSplineSurfaceForm.GENERALISED_CONE + + +quadric_surf = IfcBSplineSurfaceForm.QUADRIC_SURF + + +surf_of_linear_extrusion = IfcBSplineSurfaceForm.SURF_OF_LINEAR_EXTRUSION + + +unspecified = IfcBSplineSurfaceForm.UNSPECIFIED + + +IfcBeamTypeEnum = enum_namespace() + + +beam = IfcBeamTypeEnum.BEAM + + +joist = IfcBeamTypeEnum.JOIST + + +hollowcore = IfcBeamTypeEnum.HOLLOWCORE + + +lintel = IfcBeamTypeEnum.LINTEL + + +spandrel = IfcBeamTypeEnum.SPANDREL + + +t_beam = IfcBeamTypeEnum.T_BEAM + + +girder_segment = IfcBeamTypeEnum.GIRDER_SEGMENT + + +diaphragm = IfcBeamTypeEnum.DIAPHRAGM + + +piercap = IfcBeamTypeEnum.PIERCAP + + +hatstone = IfcBeamTypeEnum.HATSTONE + + +cornice = IfcBeamTypeEnum.CORNICE + + +edgebeam = IfcBeamTypeEnum.EDGEBEAM + + +userdefined = IfcBeamTypeEnum.USERDEFINED + + +notdefined = IfcBeamTypeEnum.NOTDEFINED + + +IfcBearingTypeDisplacementEnum = enum_namespace() + + +fixed_movement = IfcBearingTypeDisplacementEnum.FIXED_MOVEMENT + + +guided_longitudinal = IfcBearingTypeDisplacementEnum.GUIDED_LONGITUDINAL + + +guided_transversal = IfcBearingTypeDisplacementEnum.GUIDED_TRANSVERSAL + + +free_movement = IfcBearingTypeDisplacementEnum.FREE_MOVEMENT + + +notdefined = IfcBearingTypeDisplacementEnum.NOTDEFINED + + +IfcBearingTypeEnum = enum_namespace() + + +cylindrical = IfcBearingTypeEnum.CYLINDRICAL + + +spherical = IfcBearingTypeEnum.SPHERICAL + + +elastomeric = IfcBearingTypeEnum.ELASTOMERIC + + +pot = IfcBearingTypeEnum.POT + + +guide = IfcBearingTypeEnum.GUIDE + + +rocker = IfcBearingTypeEnum.ROCKER + + +roller = IfcBearingTypeEnum.ROLLER + + +disk = IfcBearingTypeEnum.DISK + + +userdefined = IfcBearingTypeEnum.USERDEFINED + + +notdefined = IfcBearingTypeEnum.NOTDEFINED + + +IfcBenchmarkEnum = enum_namespace() + + +greaterthan = IfcBenchmarkEnum.GREATERTHAN + + +greaterthanorequalto = IfcBenchmarkEnum.GREATERTHANOREQUALTO + + +lessthan = IfcBenchmarkEnum.LESSTHAN + + +lessthanorequalto = IfcBenchmarkEnum.LESSTHANOREQUALTO + + +equalto = IfcBenchmarkEnum.EQUALTO + + +notequalto = IfcBenchmarkEnum.NOTEQUALTO + + +includes = IfcBenchmarkEnum.INCLUDES + + +notincludes = IfcBenchmarkEnum.NOTINCLUDES + + +includedin = IfcBenchmarkEnum.INCLUDEDIN + + +notincludedin = IfcBenchmarkEnum.NOTINCLUDEDIN + + +IfcBoilerTypeEnum = enum_namespace() + + +water = IfcBoilerTypeEnum.WATER + + +steam = IfcBoilerTypeEnum.STEAM + + +userdefined = IfcBoilerTypeEnum.USERDEFINED + + +notdefined = IfcBoilerTypeEnum.NOTDEFINED + + +IfcBooleanOperator = enum_namespace() + + +union = IfcBooleanOperator.UNION + + +intersection = IfcBooleanOperator.INTERSECTION + + +difference = IfcBooleanOperator.DIFFERENCE + + +IfcBridgePartTypeEnum = enum_namespace() + + +abutment = IfcBridgePartTypeEnum.ABUTMENT + + +deck = IfcBridgePartTypeEnum.DECK + + +deck_segment = IfcBridgePartTypeEnum.DECK_SEGMENT + + +foundation = IfcBridgePartTypeEnum.FOUNDATION + + +pier = IfcBridgePartTypeEnum.PIER + + +pier_segment = IfcBridgePartTypeEnum.PIER_SEGMENT + + +pylon = IfcBridgePartTypeEnum.PYLON + + +substructure = IfcBridgePartTypeEnum.SUBSTRUCTURE + + +superstructure = IfcBridgePartTypeEnum.SUPERSTRUCTURE + + +surfacestructure = IfcBridgePartTypeEnum.SURFACESTRUCTURE + + +userdefined = IfcBridgePartTypeEnum.USERDEFINED + + +notdefined = IfcBridgePartTypeEnum.NOTDEFINED + + +IfcBridgeTypeEnum = enum_namespace() + + +arched = IfcBridgeTypeEnum.ARCHED + + +cable_stayed = IfcBridgeTypeEnum.CABLE_STAYED + + +cantilever = IfcBridgeTypeEnum.CANTILEVER + + +culvert = IfcBridgeTypeEnum.CULVERT + + +framework = IfcBridgeTypeEnum.FRAMEWORK + + +girder = IfcBridgeTypeEnum.GIRDER + + +suspension = IfcBridgeTypeEnum.SUSPENSION + + +truss = IfcBridgeTypeEnum.TRUSS + + +userdefined = IfcBridgeTypeEnum.USERDEFINED + + +notdefined = IfcBridgeTypeEnum.NOTDEFINED + + +IfcBuildingElementPartTypeEnum = enum_namespace() + + +insulation = IfcBuildingElementPartTypeEnum.INSULATION + + +precastpanel = IfcBuildingElementPartTypeEnum.PRECASTPANEL + + +apron = IfcBuildingElementPartTypeEnum.APRON + + +armourunit = IfcBuildingElementPartTypeEnum.ARMOURUNIT + + +safetycage = IfcBuildingElementPartTypeEnum.SAFETYCAGE + + +userdefined = IfcBuildingElementPartTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementPartTypeEnum.NOTDEFINED + + +IfcBuildingElementProxyTypeEnum = enum_namespace() + + +complex = IfcBuildingElementProxyTypeEnum.COMPLEX + + +element = IfcBuildingElementProxyTypeEnum.ELEMENT + + +partial = IfcBuildingElementProxyTypeEnum.PARTIAL + + +provisionforvoid = IfcBuildingElementProxyTypeEnum.PROVISIONFORVOID + + +provisionforspace = IfcBuildingElementProxyTypeEnum.PROVISIONFORSPACE + + +userdefined = IfcBuildingElementProxyTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementProxyTypeEnum.NOTDEFINED + + +IfcBuildingSystemTypeEnum = enum_namespace() + + +fenestration = IfcBuildingSystemTypeEnum.FENESTRATION + + +foundation = IfcBuildingSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuildingSystemTypeEnum.LOADBEARING + + +outershell = IfcBuildingSystemTypeEnum.OUTERSHELL + + +shading = IfcBuildingSystemTypeEnum.SHADING + + +transport = IfcBuildingSystemTypeEnum.TRANSPORT + + +reinforcing = IfcBuildingSystemTypeEnum.REINFORCING + + +prestressing = IfcBuildingSystemTypeEnum.PRESTRESSING + + +erosionprevention = IfcBuildingSystemTypeEnum.EROSIONPREVENTION + + +userdefined = IfcBuildingSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuildingSystemTypeEnum.NOTDEFINED + + +IfcBuiltSystemTypeEnum = enum_namespace() + + +reinforcing = IfcBuiltSystemTypeEnum.REINFORCING + + +mooring = IfcBuiltSystemTypeEnum.MOORING + + +outershell = IfcBuiltSystemTypeEnum.OUTERSHELL + + +trackcircuit = IfcBuiltSystemTypeEnum.TRACKCIRCUIT + + +erosionprevention = IfcBuiltSystemTypeEnum.EROSIONPREVENTION + + +foundation = IfcBuiltSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuiltSystemTypeEnum.LOADBEARING + + +shading = IfcBuiltSystemTypeEnum.SHADING + + +fenestration = IfcBuiltSystemTypeEnum.FENESTRATION + + +transport = IfcBuiltSystemTypeEnum.TRANSPORT + + +prestressing = IfcBuiltSystemTypeEnum.PRESTRESSING + + +userdefined = IfcBuiltSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuiltSystemTypeEnum.NOTDEFINED + + +IfcBurnerTypeEnum = enum_namespace() + + +userdefined = IfcBurnerTypeEnum.USERDEFINED + + +notdefined = IfcBurnerTypeEnum.NOTDEFINED + + +IfcCableCarrierFittingTypeEnum = enum_namespace() + + +bend = IfcCableCarrierFittingTypeEnum.BEND + + +cross = IfcCableCarrierFittingTypeEnum.CROSS + + +reducer = IfcCableCarrierFittingTypeEnum.REDUCER + + +tee = IfcCableCarrierFittingTypeEnum.TEE + + +userdefined = IfcCableCarrierFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierFittingTypeEnum.NOTDEFINED + + +IfcCableCarrierSegmentTypeEnum = enum_namespace() + + +cableladdersegment = IfcCableCarrierSegmentTypeEnum.CABLELADDERSEGMENT + + +cabletraysegment = IfcCableCarrierSegmentTypeEnum.CABLETRAYSEGMENT + + +cabletrunkingsegment = IfcCableCarrierSegmentTypeEnum.CABLETRUNKINGSEGMENT + + +conduitsegment = IfcCableCarrierSegmentTypeEnum.CONDUITSEGMENT + + +cablebracket = IfcCableCarrierSegmentTypeEnum.CABLEBRACKET + + +catenarywire = IfcCableCarrierSegmentTypeEnum.CATENARYWIRE + + +dropper = IfcCableCarrierSegmentTypeEnum.DROPPER + + +userdefined = IfcCableCarrierSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierSegmentTypeEnum.NOTDEFINED + + +IfcCableFittingTypeEnum = enum_namespace() + + +connector = IfcCableFittingTypeEnum.CONNECTOR + + +entry = IfcCableFittingTypeEnum.ENTRY + + +exit = IfcCableFittingTypeEnum.EXIT + + +junction = IfcCableFittingTypeEnum.JUNCTION + + +transition = IfcCableFittingTypeEnum.TRANSITION + + +fanout = IfcCableFittingTypeEnum.FANOUT + + +userdefined = IfcCableFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableFittingTypeEnum.NOTDEFINED + + +IfcCableSegmentTypeEnum = enum_namespace() + + +busbarsegment = IfcCableSegmentTypeEnum.BUSBARSEGMENT + + +cablesegment = IfcCableSegmentTypeEnum.CABLESEGMENT + + +conductorsegment = IfcCableSegmentTypeEnum.CONDUCTORSEGMENT + + +coresegment = IfcCableSegmentTypeEnum.CORESEGMENT + + +contactwiresegment = IfcCableSegmentTypeEnum.CONTACTWIRESEGMENT + + +fibersegment = IfcCableSegmentTypeEnum.FIBERSEGMENT + + +fibertube = IfcCableSegmentTypeEnum.FIBERTUBE + + +opticalcablesegment = IfcCableSegmentTypeEnum.OPTICALCABLESEGMENT + + +stitchwire = IfcCableSegmentTypeEnum.STITCHWIRE + + +wirepairsegment = IfcCableSegmentTypeEnum.WIREPAIRSEGMENT + + +userdefined = IfcCableSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableSegmentTypeEnum.NOTDEFINED + + +IfcCaissonFoundationTypeEnum = enum_namespace() + + +well = IfcCaissonFoundationTypeEnum.WELL + + +caisson = IfcCaissonFoundationTypeEnum.CAISSON + + +userdefined = IfcCaissonFoundationTypeEnum.USERDEFINED + + +notdefined = IfcCaissonFoundationTypeEnum.NOTDEFINED + + +IfcChangeActionEnum = enum_namespace() + + +nochange = IfcChangeActionEnum.NOCHANGE + + +modified = IfcChangeActionEnum.MODIFIED + + +added = IfcChangeActionEnum.ADDED + + +deleted = IfcChangeActionEnum.DELETED + + +notdefined = IfcChangeActionEnum.NOTDEFINED + + +IfcChillerTypeEnum = enum_namespace() + + +aircooled = IfcChillerTypeEnum.AIRCOOLED + + +watercooled = IfcChillerTypeEnum.WATERCOOLED + + +heatrecovery = IfcChillerTypeEnum.HEATRECOVERY + + +userdefined = IfcChillerTypeEnum.USERDEFINED + + +notdefined = IfcChillerTypeEnum.NOTDEFINED + + +IfcChimneyTypeEnum = enum_namespace() + + +userdefined = IfcChimneyTypeEnum.USERDEFINED + + +notdefined = IfcChimneyTypeEnum.NOTDEFINED + + +IfcCoilTypeEnum = enum_namespace() + + +dxcoolingcoil = IfcCoilTypeEnum.DXCOOLINGCOIL + + +electricheatingcoil = IfcCoilTypeEnum.ELECTRICHEATINGCOIL + + +gasheatingcoil = IfcCoilTypeEnum.GASHEATINGCOIL + + +hydroniccoil = IfcCoilTypeEnum.HYDRONICCOIL + + +steamheatingcoil = IfcCoilTypeEnum.STEAMHEATINGCOIL + + +watercoolingcoil = IfcCoilTypeEnum.WATERCOOLINGCOIL + + +waterheatingcoil = IfcCoilTypeEnum.WATERHEATINGCOIL + + +userdefined = IfcCoilTypeEnum.USERDEFINED + + +notdefined = IfcCoilTypeEnum.NOTDEFINED + + +IfcColumnTypeEnum = enum_namespace() + + +column = IfcColumnTypeEnum.COLUMN + + +pilaster = IfcColumnTypeEnum.PILASTER + + +pierstem = IfcColumnTypeEnum.PIERSTEM + + +pierstem_segment = IfcColumnTypeEnum.PIERSTEM_SEGMENT + + +standcolumn = IfcColumnTypeEnum.STANDCOLUMN + + +userdefined = IfcColumnTypeEnum.USERDEFINED + + +notdefined = IfcColumnTypeEnum.NOTDEFINED + + +IfcCommunicationsApplianceTypeEnum = enum_namespace() + + +antenna = IfcCommunicationsApplianceTypeEnum.ANTENNA + + +computer = IfcCommunicationsApplianceTypeEnum.COMPUTER + + +fax = IfcCommunicationsApplianceTypeEnum.FAX + + +gateway = IfcCommunicationsApplianceTypeEnum.GATEWAY + + +modem = IfcCommunicationsApplianceTypeEnum.MODEM + + +networkappliance = IfcCommunicationsApplianceTypeEnum.NETWORKAPPLIANCE + + +networkbridge = IfcCommunicationsApplianceTypeEnum.NETWORKBRIDGE + + +networkhub = IfcCommunicationsApplianceTypeEnum.NETWORKHUB + + +printer = IfcCommunicationsApplianceTypeEnum.PRINTER + + +repeater = IfcCommunicationsApplianceTypeEnum.REPEATER + + +router = IfcCommunicationsApplianceTypeEnum.ROUTER + + +scanner = IfcCommunicationsApplianceTypeEnum.SCANNER + + +automaton = IfcCommunicationsApplianceTypeEnum.AUTOMATON + + +intelligentperipheral = IfcCommunicationsApplianceTypeEnum.INTELLIGENTPERIPHERAL + + +ipnetworkequipment = IfcCommunicationsApplianceTypeEnum.IPNETWORKEQUIPMENT + + +opticalnetworkunit = IfcCommunicationsApplianceTypeEnum.OPTICALNETWORKUNIT + + +telecommand = IfcCommunicationsApplianceTypeEnum.TELECOMMAND + + +telephonyexchange = IfcCommunicationsApplianceTypeEnum.TELEPHONYEXCHANGE + + +transitioncomponent = IfcCommunicationsApplianceTypeEnum.TRANSITIONCOMPONENT + + +transponder = IfcCommunicationsApplianceTypeEnum.TRANSPONDER + + +transportequipment = IfcCommunicationsApplianceTypeEnum.TRANSPORTEQUIPMENT + + +opticallineterminal = IfcCommunicationsApplianceTypeEnum.OPTICALLINETERMINAL + + +linesideelectronicunit = IfcCommunicationsApplianceTypeEnum.LINESIDEELECTRONICUNIT + + +radioblockcenter = IfcCommunicationsApplianceTypeEnum.RADIOBLOCKCENTER + + +userdefined = IfcCommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcCommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcComplexPropertyTemplateTypeEnum = enum_namespace() + + +p_complex = IfcComplexPropertyTemplateTypeEnum.P_COMPLEX + + +q_complex = IfcComplexPropertyTemplateTypeEnum.Q_COMPLEX + + +IfcCompressorTypeEnum = enum_namespace() + + +dynamic = IfcCompressorTypeEnum.DYNAMIC + + +reciprocating = IfcCompressorTypeEnum.RECIPROCATING + + +rotary = IfcCompressorTypeEnum.ROTARY + + +scroll = IfcCompressorTypeEnum.SCROLL + + +trochoidal = IfcCompressorTypeEnum.TROCHOIDAL + + +singlestage = IfcCompressorTypeEnum.SINGLESTAGE + + +booster = IfcCompressorTypeEnum.BOOSTER + + +opentype = IfcCompressorTypeEnum.OPENTYPE + + +hermetic = IfcCompressorTypeEnum.HERMETIC + + +semihermetic = IfcCompressorTypeEnum.SEMIHERMETIC + + +weldedshellhermetic = IfcCompressorTypeEnum.WELDEDSHELLHERMETIC + + +rollingpiston = IfcCompressorTypeEnum.ROLLINGPISTON + + +rotaryvane = IfcCompressorTypeEnum.ROTARYVANE + + +singlescrew = IfcCompressorTypeEnum.SINGLESCREW + + +twinscrew = IfcCompressorTypeEnum.TWINSCREW + + +userdefined = IfcCompressorTypeEnum.USERDEFINED + + +notdefined = IfcCompressorTypeEnum.NOTDEFINED + + +IfcCondenserTypeEnum = enum_namespace() + + +aircooled = IfcCondenserTypeEnum.AIRCOOLED + + +evaporativecooled = IfcCondenserTypeEnum.EVAPORATIVECOOLED + + +watercooled = IfcCondenserTypeEnum.WATERCOOLED + + +watercooledbrazedplate = IfcCondenserTypeEnum.WATERCOOLEDBRAZEDPLATE + + +watercooledshellcoil = IfcCondenserTypeEnum.WATERCOOLEDSHELLCOIL + + +watercooledshelltube = IfcCondenserTypeEnum.WATERCOOLEDSHELLTUBE + + +watercooledtubeintube = IfcCondenserTypeEnum.WATERCOOLEDTUBEINTUBE + + +userdefined = IfcCondenserTypeEnum.USERDEFINED + + +notdefined = IfcCondenserTypeEnum.NOTDEFINED + + +IfcConnectionTypeEnum = enum_namespace() + + +atpath = IfcConnectionTypeEnum.ATPATH + + +atstart = IfcConnectionTypeEnum.ATSTART + + +atend = IfcConnectionTypeEnum.ATEND + + +notdefined = IfcConnectionTypeEnum.NOTDEFINED + + +IfcConstraintEnum = enum_namespace() + + +hard = IfcConstraintEnum.HARD + + +soft = IfcConstraintEnum.SOFT + + +advisory = IfcConstraintEnum.ADVISORY + + +userdefined = IfcConstraintEnum.USERDEFINED + + +notdefined = IfcConstraintEnum.NOTDEFINED + + +IfcConstructionEquipmentResourceTypeEnum = enum_namespace() + + +demolishing = IfcConstructionEquipmentResourceTypeEnum.DEMOLISHING + + +earthmoving = IfcConstructionEquipmentResourceTypeEnum.EARTHMOVING + + +erecting = IfcConstructionEquipmentResourceTypeEnum.ERECTING + + +heating = IfcConstructionEquipmentResourceTypeEnum.HEATING + + +lighting = IfcConstructionEquipmentResourceTypeEnum.LIGHTING + + +paving = IfcConstructionEquipmentResourceTypeEnum.PAVING + + +pumping = IfcConstructionEquipmentResourceTypeEnum.PUMPING + + +transporting = IfcConstructionEquipmentResourceTypeEnum.TRANSPORTING + + +userdefined = IfcConstructionEquipmentResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionEquipmentResourceTypeEnum.NOTDEFINED + + +IfcConstructionMaterialResourceTypeEnum = enum_namespace() + + +aggregates = IfcConstructionMaterialResourceTypeEnum.AGGREGATES + + +concrete = IfcConstructionMaterialResourceTypeEnum.CONCRETE + + +drywall = IfcConstructionMaterialResourceTypeEnum.DRYWALL + + +fuel = IfcConstructionMaterialResourceTypeEnum.FUEL + + +gypsum = IfcConstructionMaterialResourceTypeEnum.GYPSUM + + +masonry = IfcConstructionMaterialResourceTypeEnum.MASONRY + + +metal = IfcConstructionMaterialResourceTypeEnum.METAL + + +plastic = IfcConstructionMaterialResourceTypeEnum.PLASTIC + + +wood = IfcConstructionMaterialResourceTypeEnum.WOOD + + +notdefined = IfcConstructionMaterialResourceTypeEnum.NOTDEFINED + + +userdefined = IfcConstructionMaterialResourceTypeEnum.USERDEFINED + + +IfcConstructionProductResourceTypeEnum = enum_namespace() + + +assembly = IfcConstructionProductResourceTypeEnum.ASSEMBLY + + +formwork = IfcConstructionProductResourceTypeEnum.FORMWORK + + +userdefined = IfcConstructionProductResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionProductResourceTypeEnum.NOTDEFINED + + +IfcControllerTypeEnum = enum_namespace() + + +floating = IfcControllerTypeEnum.FLOATING + + +programmable = IfcControllerTypeEnum.PROGRAMMABLE + + +proportional = IfcControllerTypeEnum.PROPORTIONAL + + +multiposition = IfcControllerTypeEnum.MULTIPOSITION + + +twoposition = IfcControllerTypeEnum.TWOPOSITION + + +userdefined = IfcControllerTypeEnum.USERDEFINED + + +notdefined = IfcControllerTypeEnum.NOTDEFINED + + +IfcConveyorSegmentTypeEnum = enum_namespace() + + +chuteconveyor = IfcConveyorSegmentTypeEnum.CHUTECONVEYOR + + +beltconveyor = IfcConveyorSegmentTypeEnum.BELTCONVEYOR + + +screwconveyor = IfcConveyorSegmentTypeEnum.SCREWCONVEYOR + + +bucketconveyor = IfcConveyorSegmentTypeEnum.BUCKETCONVEYOR + + +userdefined = IfcConveyorSegmentTypeEnum.USERDEFINED + + +notdefined = IfcConveyorSegmentTypeEnum.NOTDEFINED + + +IfcCooledBeamTypeEnum = enum_namespace() + + +active = IfcCooledBeamTypeEnum.ACTIVE + + +passive = IfcCooledBeamTypeEnum.PASSIVE + + +userdefined = IfcCooledBeamTypeEnum.USERDEFINED + + +notdefined = IfcCooledBeamTypeEnum.NOTDEFINED + + +IfcCoolingTowerTypeEnum = enum_namespace() + + +naturaldraft = IfcCoolingTowerTypeEnum.NATURALDRAFT + + +mechanicalinduceddraft = IfcCoolingTowerTypeEnum.MECHANICALINDUCEDDRAFT + + +mechanicalforceddraft = IfcCoolingTowerTypeEnum.MECHANICALFORCEDDRAFT + + +userdefined = IfcCoolingTowerTypeEnum.USERDEFINED + + +notdefined = IfcCoolingTowerTypeEnum.NOTDEFINED + + +IfcCostItemTypeEnum = enum_namespace() + + +userdefined = IfcCostItemTypeEnum.USERDEFINED + + +notdefined = IfcCostItemTypeEnum.NOTDEFINED + + +IfcCostScheduleTypeEnum = enum_namespace() + + +budget = IfcCostScheduleTypeEnum.BUDGET + + +costplan = IfcCostScheduleTypeEnum.COSTPLAN + + +estimate = IfcCostScheduleTypeEnum.ESTIMATE + + +tender = IfcCostScheduleTypeEnum.TENDER + + +pricedbillofquantities = IfcCostScheduleTypeEnum.PRICEDBILLOFQUANTITIES + + +unpricedbillofquantities = IfcCostScheduleTypeEnum.UNPRICEDBILLOFQUANTITIES + + +scheduleofrates = IfcCostScheduleTypeEnum.SCHEDULEOFRATES + + +userdefined = IfcCostScheduleTypeEnum.USERDEFINED + + +notdefined = IfcCostScheduleTypeEnum.NOTDEFINED + + +IfcCourseTypeEnum = enum_namespace() + + +armour = IfcCourseTypeEnum.ARMOUR + + +filter = IfcCourseTypeEnum.FILTER + + +ballastbed = IfcCourseTypeEnum.BALLASTBED + + +core = IfcCourseTypeEnum.CORE + + +pavement = IfcCourseTypeEnum.PAVEMENT + + +protection = IfcCourseTypeEnum.PROTECTION + + +userdefined = IfcCourseTypeEnum.USERDEFINED + + +notdefined = IfcCourseTypeEnum.NOTDEFINED + + +IfcCoveringTypeEnum = enum_namespace() + + +ceiling = IfcCoveringTypeEnum.CEILING + + +flooring = IfcCoveringTypeEnum.FLOORING + + +cladding = IfcCoveringTypeEnum.CLADDING + + +roofing = IfcCoveringTypeEnum.ROOFING + + +molding = IfcCoveringTypeEnum.MOLDING + + +skirtingboard = IfcCoveringTypeEnum.SKIRTINGBOARD + + +insulation = IfcCoveringTypeEnum.INSULATION + + +membrane = IfcCoveringTypeEnum.MEMBRANE + + +sleeving = IfcCoveringTypeEnum.SLEEVING + + +wrapping = IfcCoveringTypeEnum.WRAPPING + + +coping = IfcCoveringTypeEnum.COPING + + +userdefined = IfcCoveringTypeEnum.USERDEFINED + + +notdefined = IfcCoveringTypeEnum.NOTDEFINED + + +IfcCrewResourceTypeEnum = enum_namespace() + + +office = IfcCrewResourceTypeEnum.OFFICE + + +site = IfcCrewResourceTypeEnum.SITE + + +userdefined = IfcCrewResourceTypeEnum.USERDEFINED + + +notdefined = IfcCrewResourceTypeEnum.NOTDEFINED + + +IfcCurtainWallTypeEnum = enum_namespace() + + +userdefined = IfcCurtainWallTypeEnum.USERDEFINED + + +notdefined = IfcCurtainWallTypeEnum.NOTDEFINED + + +IfcCurveInterpolationEnum = enum_namespace() + + +linear = IfcCurveInterpolationEnum.LINEAR + + +log_linear = IfcCurveInterpolationEnum.LOG_LINEAR + + +log_log = IfcCurveInterpolationEnum.LOG_LOG + + +notdefined = IfcCurveInterpolationEnum.NOTDEFINED + + +IfcDamperTypeEnum = enum_namespace() + + +backdraftdamper = IfcDamperTypeEnum.BACKDRAFTDAMPER + + +balancingdamper = IfcDamperTypeEnum.BALANCINGDAMPER + + +blastdamper = IfcDamperTypeEnum.BLASTDAMPER + + +controldamper = IfcDamperTypeEnum.CONTROLDAMPER + + +firedamper = IfcDamperTypeEnum.FIREDAMPER + + +firesmokedamper = IfcDamperTypeEnum.FIRESMOKEDAMPER + + +fumehoodexhaust = IfcDamperTypeEnum.FUMEHOODEXHAUST + + +gravitydamper = IfcDamperTypeEnum.GRAVITYDAMPER + + +gravityreliefdamper = IfcDamperTypeEnum.GRAVITYRELIEFDAMPER + + +reliefdamper = IfcDamperTypeEnum.RELIEFDAMPER + + +smokedamper = IfcDamperTypeEnum.SMOKEDAMPER + + +userdefined = IfcDamperTypeEnum.USERDEFINED + + +notdefined = IfcDamperTypeEnum.NOTDEFINED + + +IfcDataOriginEnum = enum_namespace() + + +measured = IfcDataOriginEnum.MEASURED + + +predicted = IfcDataOriginEnum.PREDICTED + + +simulated = IfcDataOriginEnum.SIMULATED + + +userdefined = IfcDataOriginEnum.USERDEFINED + + +notdefined = IfcDataOriginEnum.NOTDEFINED + + +IfcDerivedUnitEnum = enum_namespace() + + +angularvelocityunit = IfcDerivedUnitEnum.ANGULARVELOCITYUNIT + + +areadensityunit = IfcDerivedUnitEnum.AREADENSITYUNIT + + +compoundplaneangleunit = IfcDerivedUnitEnum.COMPOUNDPLANEANGLEUNIT + + +dynamicviscosityunit = IfcDerivedUnitEnum.DYNAMICVISCOSITYUNIT + + +heatfluxdensityunit = IfcDerivedUnitEnum.HEATFLUXDENSITYUNIT + + +integercountrateunit = IfcDerivedUnitEnum.INTEGERCOUNTRATEUNIT + + +isothermalmoisturecapacityunit = IfcDerivedUnitEnum.ISOTHERMALMOISTURECAPACITYUNIT + + +kinematicviscosityunit = IfcDerivedUnitEnum.KINEMATICVISCOSITYUNIT + + +linearvelocityunit = IfcDerivedUnitEnum.LINEARVELOCITYUNIT + + +massdensityunit = IfcDerivedUnitEnum.MASSDENSITYUNIT + + +massflowrateunit = IfcDerivedUnitEnum.MASSFLOWRATEUNIT + + +moisturediffusivityunit = IfcDerivedUnitEnum.MOISTUREDIFFUSIVITYUNIT + + +molecularweightunit = IfcDerivedUnitEnum.MOLECULARWEIGHTUNIT + + +specificheatcapacityunit = IfcDerivedUnitEnum.SPECIFICHEATCAPACITYUNIT + + +thermaladmittanceunit = IfcDerivedUnitEnum.THERMALADMITTANCEUNIT + + +thermalconductanceunit = IfcDerivedUnitEnum.THERMALCONDUCTANCEUNIT + + +thermalresistanceunit = IfcDerivedUnitEnum.THERMALRESISTANCEUNIT + + +thermaltransmittanceunit = IfcDerivedUnitEnum.THERMALTRANSMITTANCEUNIT + + +vaporpermeabilityunit = IfcDerivedUnitEnum.VAPORPERMEABILITYUNIT + + +volumetricflowrateunit = IfcDerivedUnitEnum.VOLUMETRICFLOWRATEUNIT + + +rotationalfrequencyunit = IfcDerivedUnitEnum.ROTATIONALFREQUENCYUNIT + + +torqueunit = IfcDerivedUnitEnum.TORQUEUNIT + + +momentofinertiaunit = IfcDerivedUnitEnum.MOMENTOFINERTIAUNIT + + +linearmomentunit = IfcDerivedUnitEnum.LINEARMOMENTUNIT + + +linearforceunit = IfcDerivedUnitEnum.LINEARFORCEUNIT + + +planarforceunit = IfcDerivedUnitEnum.PLANARFORCEUNIT + + +modulusofelasticityunit = IfcDerivedUnitEnum.MODULUSOFELASTICITYUNIT + + +shearmodulusunit = IfcDerivedUnitEnum.SHEARMODULUSUNIT + + +linearstiffnessunit = IfcDerivedUnitEnum.LINEARSTIFFNESSUNIT + + +rotationalstiffnessunit = IfcDerivedUnitEnum.ROTATIONALSTIFFNESSUNIT + + +modulusofsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFSUBGRADEREACTIONUNIT + + +accelerationunit = IfcDerivedUnitEnum.ACCELERATIONUNIT + + +curvatureunit = IfcDerivedUnitEnum.CURVATUREUNIT + + +heatingvalueunit = IfcDerivedUnitEnum.HEATINGVALUEUNIT + + +ionconcentrationunit = IfcDerivedUnitEnum.IONCONCENTRATIONUNIT + + +luminousintensitydistributionunit = IfcDerivedUnitEnum.LUMINOUSINTENSITYDISTRIBUTIONUNIT + + +massperlengthunit = IfcDerivedUnitEnum.MASSPERLENGTHUNIT + + +modulusoflinearsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFLINEARSUBGRADEREACTIONUNIT + + +modulusofrotationalsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFROTATIONALSUBGRADEREACTIONUNIT + + +phunit = IfcDerivedUnitEnum.PHUNIT + + +rotationalmassunit = IfcDerivedUnitEnum.ROTATIONALMASSUNIT + + +sectionareaintegralunit = IfcDerivedUnitEnum.SECTIONAREAINTEGRALUNIT + + +sectionmodulusunit = IfcDerivedUnitEnum.SECTIONMODULUSUNIT + + +soundpowerlevelunit = IfcDerivedUnitEnum.SOUNDPOWERLEVELUNIT + + +soundpowerunit = IfcDerivedUnitEnum.SOUNDPOWERUNIT + + +soundpressurelevelunit = IfcDerivedUnitEnum.SOUNDPRESSURELEVELUNIT + + +soundpressureunit = IfcDerivedUnitEnum.SOUNDPRESSUREUNIT + + +temperaturegradientunit = IfcDerivedUnitEnum.TEMPERATUREGRADIENTUNIT + + +temperaturerateofchangeunit = IfcDerivedUnitEnum.TEMPERATURERATEOFCHANGEUNIT + + +thermalexpansioncoefficientunit = IfcDerivedUnitEnum.THERMALEXPANSIONCOEFFICIENTUNIT + + +warpingconstantunit = IfcDerivedUnitEnum.WARPINGCONSTANTUNIT + + +warpingmomentunit = IfcDerivedUnitEnum.WARPINGMOMENTUNIT + + +userdefined = IfcDerivedUnitEnum.USERDEFINED + + +IfcDirectionSenseEnum = enum_namespace() + + +positive = IfcDirectionSenseEnum.POSITIVE + + +negative = IfcDirectionSenseEnum.NEGATIVE + + +IfcDiscreteAccessoryTypeEnum = enum_namespace() + + +anchorplate = IfcDiscreteAccessoryTypeEnum.ANCHORPLATE + + +bracket = IfcDiscreteAccessoryTypeEnum.BRACKET + + +shoe = IfcDiscreteAccessoryTypeEnum.SHOE + + +expansion_joint_device = IfcDiscreteAccessoryTypeEnum.EXPANSION_JOINT_DEVICE + + +cablearranger = IfcDiscreteAccessoryTypeEnum.CABLEARRANGER + + +insulator = IfcDiscreteAccessoryTypeEnum.INSULATOR + + +lock = IfcDiscreteAccessoryTypeEnum.LOCK + + +tensioningequipment = IfcDiscreteAccessoryTypeEnum.TENSIONINGEQUIPMENT + + +railpad = IfcDiscreteAccessoryTypeEnum.RAILPAD + + +slidingchair = IfcDiscreteAccessoryTypeEnum.SLIDINGCHAIR + + +rail_lubrication = IfcDiscreteAccessoryTypeEnum.RAIL_LUBRICATION + + +panel_strengthening = IfcDiscreteAccessoryTypeEnum.PANEL_STRENGTHENING + + +railbrace = IfcDiscreteAccessoryTypeEnum.RAILBRACE + + +elastic_cushion = IfcDiscreteAccessoryTypeEnum.ELASTIC_CUSHION + + +soundabsorption = IfcDiscreteAccessoryTypeEnum.SOUNDABSORPTION + + +pointmachinemountingdevice = IfcDiscreteAccessoryTypeEnum.POINTMACHINEMOUNTINGDEVICE + + +point_machine_locking_device = IfcDiscreteAccessoryTypeEnum.POINT_MACHINE_LOCKING_DEVICE + + +rail_mechanical_equipment = IfcDiscreteAccessoryTypeEnum.RAIL_MECHANICAL_EQUIPMENT + + +birdprotection = IfcDiscreteAccessoryTypeEnum.BIRDPROTECTION + + +userdefined = IfcDiscreteAccessoryTypeEnum.USERDEFINED + + +notdefined = IfcDiscreteAccessoryTypeEnum.NOTDEFINED + + +IfcDistributionBoardTypeEnum = enum_namespace() + + +switchboard = IfcDistributionBoardTypeEnum.SWITCHBOARD + + +consumerunit = IfcDistributionBoardTypeEnum.CONSUMERUNIT + + +motorcontrolcentre = IfcDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +distributionframe = IfcDistributionBoardTypeEnum.DISTRIBUTIONFRAME + + +distributionboard = IfcDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +dispatchingboard = IfcDistributionBoardTypeEnum.DISPATCHINGBOARD + + +userdefined = IfcDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcDistributionBoardTypeEnum.NOTDEFINED + + +IfcDistributionChamberElementTypeEnum = enum_namespace() + + +formedduct = IfcDistributionChamberElementTypeEnum.FORMEDDUCT + + +inspectionchamber = IfcDistributionChamberElementTypeEnum.INSPECTIONCHAMBER + + +inspectionpit = IfcDistributionChamberElementTypeEnum.INSPECTIONPIT + + +manhole = IfcDistributionChamberElementTypeEnum.MANHOLE + + +meterchamber = IfcDistributionChamberElementTypeEnum.METERCHAMBER + + +sump = IfcDistributionChamberElementTypeEnum.SUMP + + +trench = IfcDistributionChamberElementTypeEnum.TRENCH + + +valvechamber = IfcDistributionChamberElementTypeEnum.VALVECHAMBER + + +userdefined = IfcDistributionChamberElementTypeEnum.USERDEFINED + + +notdefined = IfcDistributionChamberElementTypeEnum.NOTDEFINED + + +IfcDistributionPortTypeEnum = enum_namespace() + + +cable = IfcDistributionPortTypeEnum.CABLE + + +cablecarrier = IfcDistributionPortTypeEnum.CABLECARRIER + + +duct = IfcDistributionPortTypeEnum.DUCT + + +pipe = IfcDistributionPortTypeEnum.PIPE + + +wireless = IfcDistributionPortTypeEnum.WIRELESS + + +userdefined = IfcDistributionPortTypeEnum.USERDEFINED + + +notdefined = IfcDistributionPortTypeEnum.NOTDEFINED + + +IfcDistributionSystemEnum = enum_namespace() + + +airconditioning = IfcDistributionSystemEnum.AIRCONDITIONING + + +audiovisual = IfcDistributionSystemEnum.AUDIOVISUAL + + +chemical = IfcDistributionSystemEnum.CHEMICAL + + +chilledwater = IfcDistributionSystemEnum.CHILLEDWATER + + +communication = IfcDistributionSystemEnum.COMMUNICATION + + +compressedair = IfcDistributionSystemEnum.COMPRESSEDAIR + + +condenserwater = IfcDistributionSystemEnum.CONDENSERWATER + + +control = IfcDistributionSystemEnum.CONTROL + + +conveying = IfcDistributionSystemEnum.CONVEYING + + +data = IfcDistributionSystemEnum.DATA + + +disposal = IfcDistributionSystemEnum.DISPOSAL + + +domesticcoldwater = IfcDistributionSystemEnum.DOMESTICCOLDWATER + + +domestichotwater = IfcDistributionSystemEnum.DOMESTICHOTWATER + + +drainage = IfcDistributionSystemEnum.DRAINAGE + + +earthing = IfcDistributionSystemEnum.EARTHING + + +electrical = IfcDistributionSystemEnum.ELECTRICAL + + +electroacoustic = IfcDistributionSystemEnum.ELECTROACOUSTIC + + +exhaust = IfcDistributionSystemEnum.EXHAUST + + +fireprotection = IfcDistributionSystemEnum.FIREPROTECTION + + +fuel = IfcDistributionSystemEnum.FUEL + + +gas = IfcDistributionSystemEnum.GAS + + +hazardous = IfcDistributionSystemEnum.HAZARDOUS + + +heating = IfcDistributionSystemEnum.HEATING + + +lighting = IfcDistributionSystemEnum.LIGHTING + + +lightningprotection = IfcDistributionSystemEnum.LIGHTNINGPROTECTION + + +municipalsolidwaste = IfcDistributionSystemEnum.MUNICIPALSOLIDWASTE + + +oil = IfcDistributionSystemEnum.OIL + + +operational = IfcDistributionSystemEnum.OPERATIONAL + + +powergeneration = IfcDistributionSystemEnum.POWERGENERATION + + +rainwater = IfcDistributionSystemEnum.RAINWATER + + +refrigeration = IfcDistributionSystemEnum.REFRIGERATION + + +security = IfcDistributionSystemEnum.SECURITY + + +sewage = IfcDistributionSystemEnum.SEWAGE + + +signal = IfcDistributionSystemEnum.SIGNAL + + +stormwater = IfcDistributionSystemEnum.STORMWATER + + +telephone = IfcDistributionSystemEnum.TELEPHONE + + +tv = IfcDistributionSystemEnum.TV + + +vacuum = IfcDistributionSystemEnum.VACUUM + + +vent = IfcDistributionSystemEnum.VENT + + +ventilation = IfcDistributionSystemEnum.VENTILATION + + +wastewater = IfcDistributionSystemEnum.WASTEWATER + + +watersupply = IfcDistributionSystemEnum.WATERSUPPLY + + +catenary_system = IfcDistributionSystemEnum.CATENARY_SYSTEM + + +overhead_contactline_system = IfcDistributionSystemEnum.OVERHEAD_CONTACTLINE_SYSTEM + + +return_circuit = IfcDistributionSystemEnum.RETURN_CIRCUIT + + +fixedtransmissionnetwork = IfcDistributionSystemEnum.FIXEDTRANSMISSIONNETWORK + + +operationaltelephonysystem = IfcDistributionSystemEnum.OPERATIONALTELEPHONYSYSTEM + + +mobilenetwork = IfcDistributionSystemEnum.MOBILENETWORK + + +monitoringsystem = IfcDistributionSystemEnum.MONITORINGSYSTEM + + +userdefined = IfcDistributionSystemEnum.USERDEFINED + + +notdefined = IfcDistributionSystemEnum.NOTDEFINED + + +IfcDocumentConfidentialityEnum = enum_namespace() + + +public = IfcDocumentConfidentialityEnum.PUBLIC + + +restricted = IfcDocumentConfidentialityEnum.RESTRICTED + + +confidential = IfcDocumentConfidentialityEnum.CONFIDENTIAL + + +personal = IfcDocumentConfidentialityEnum.PERSONAL + + +userdefined = IfcDocumentConfidentialityEnum.USERDEFINED + + +notdefined = IfcDocumentConfidentialityEnum.NOTDEFINED + + +IfcDocumentStatusEnum = enum_namespace() + + +draft = IfcDocumentStatusEnum.DRAFT + + +finaldraft = IfcDocumentStatusEnum.FINALDRAFT + + +final = IfcDocumentStatusEnum.FINAL + + +revision = IfcDocumentStatusEnum.REVISION + + +notdefined = IfcDocumentStatusEnum.NOTDEFINED + + +IfcDoorPanelOperationEnum = enum_namespace() + + +swinging = IfcDoorPanelOperationEnum.SWINGING + + +double_acting = IfcDoorPanelOperationEnum.DOUBLE_ACTING + + +sliding = IfcDoorPanelOperationEnum.SLIDING + + +folding = IfcDoorPanelOperationEnum.FOLDING + + +revolving = IfcDoorPanelOperationEnum.REVOLVING + + +rollingup = IfcDoorPanelOperationEnum.ROLLINGUP + + +fixedpanel = IfcDoorPanelOperationEnum.FIXEDPANEL + + +userdefined = IfcDoorPanelOperationEnum.USERDEFINED + + +notdefined = IfcDoorPanelOperationEnum.NOTDEFINED + + +IfcDoorPanelPositionEnum = enum_namespace() + + +left = IfcDoorPanelPositionEnum.LEFT + + +middle = IfcDoorPanelPositionEnum.MIDDLE + + +right = IfcDoorPanelPositionEnum.RIGHT + + +notdefined = IfcDoorPanelPositionEnum.NOTDEFINED + + +IfcDoorStyleConstructionEnum = enum_namespace() + + +aluminium = IfcDoorStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcDoorStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcDoorStyleConstructionEnum.STEEL + + +wood = IfcDoorStyleConstructionEnum.WOOD + + +aluminium_wood = IfcDoorStyleConstructionEnum.ALUMINIUM_WOOD + + +aluminium_plastic = IfcDoorStyleConstructionEnum.ALUMINIUM_PLASTIC + + +plastic = IfcDoorStyleConstructionEnum.PLASTIC + + +userdefined = IfcDoorStyleConstructionEnum.USERDEFINED + + +notdefined = IfcDoorStyleConstructionEnum.NOTDEFINED + + +IfcDoorStyleOperationEnum = enum_namespace() + + +single_swing_left = IfcDoorStyleOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorStyleOperationEnum.SINGLE_SWING_RIGHT + + +double_door_single_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_swing_left = IfcDoorStyleOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorStyleOperationEnum.DOUBLE_SWING_RIGHT + + +double_door_double_swing = IfcDoorStyleOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +sliding_to_left = IfcDoorStyleOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorStyleOperationEnum.SLIDING_TO_RIGHT + + +double_door_sliding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_SLIDING + + +folding_to_left = IfcDoorStyleOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorStyleOperationEnum.FOLDING_TO_RIGHT + + +double_door_folding = IfcDoorStyleOperationEnum.DOUBLE_DOOR_FOLDING + + +revolving = IfcDoorStyleOperationEnum.REVOLVING + + +rollingup = IfcDoorStyleOperationEnum.ROLLINGUP + + +userdefined = IfcDoorStyleOperationEnum.USERDEFINED + + +notdefined = IfcDoorStyleOperationEnum.NOTDEFINED + + +IfcDoorTypeEnum = enum_namespace() + + +door = IfcDoorTypeEnum.DOOR + + +gate = IfcDoorTypeEnum.GATE + + +trapdoor = IfcDoorTypeEnum.TRAPDOOR + + +boom_barrier = IfcDoorTypeEnum.BOOM_BARRIER + + +turnstile = IfcDoorTypeEnum.TURNSTILE + + +userdefined = IfcDoorTypeEnum.USERDEFINED + + +notdefined = IfcDoorTypeEnum.NOTDEFINED + + +IfcDoorTypeOperationEnum = enum_namespace() + + +single_swing_left = IfcDoorTypeOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorTypeOperationEnum.SINGLE_SWING_RIGHT + + +double_panel_single_swing = IfcDoorTypeOperationEnum.DOUBLE_PANEL_SINGLE_SWING + + +double_panel_single_swing_opposite_left = IfcDoorTypeOperationEnum.DOUBLE_PANEL_SINGLE_SWING_OPPOSITE_LEFT + + +double_panel_single_swing_opposite_right = IfcDoorTypeOperationEnum.DOUBLE_PANEL_SINGLE_SWING_OPPOSITE_RIGHT + + +double_swing_left = IfcDoorTypeOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorTypeOperationEnum.DOUBLE_SWING_RIGHT + + +double_panel_double_swing = IfcDoorTypeOperationEnum.DOUBLE_PANEL_DOUBLE_SWING + + +sliding_to_left = IfcDoorTypeOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorTypeOperationEnum.SLIDING_TO_RIGHT + + +double_panel_sliding = IfcDoorTypeOperationEnum.DOUBLE_PANEL_SLIDING + + +folding_to_left = IfcDoorTypeOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorTypeOperationEnum.FOLDING_TO_RIGHT + + +double_panel_folding = IfcDoorTypeOperationEnum.DOUBLE_PANEL_FOLDING + + +revolving_horizontal = IfcDoorTypeOperationEnum.REVOLVING_HORIZONTAL + + +rollingup = IfcDoorTypeOperationEnum.ROLLINGUP + + +swing_fixed_left = IfcDoorTypeOperationEnum.SWING_FIXED_LEFT + + +swing_fixed_right = IfcDoorTypeOperationEnum.SWING_FIXED_RIGHT + + +double_panel_lifting_vertical = IfcDoorTypeOperationEnum.DOUBLE_PANEL_LIFTING_VERTICAL + + +lifting_horizontal = IfcDoorTypeOperationEnum.LIFTING_HORIZONTAL + + +lifting_vertical_left = IfcDoorTypeOperationEnum.LIFTING_VERTICAL_LEFT + + +lifting_vertical_right = IfcDoorTypeOperationEnum.LIFTING_VERTICAL_RIGHT + + +revolving_vertical = IfcDoorTypeOperationEnum.REVOLVING_VERTICAL + + +userdefined = IfcDoorTypeOperationEnum.USERDEFINED + + +notdefined = IfcDoorTypeOperationEnum.NOTDEFINED + + +IfcDuctFittingTypeEnum = enum_namespace() + + +bend = IfcDuctFittingTypeEnum.BEND + + +connector = IfcDuctFittingTypeEnum.CONNECTOR + + +entry = IfcDuctFittingTypeEnum.ENTRY + + +exit = IfcDuctFittingTypeEnum.EXIT + + +junction = IfcDuctFittingTypeEnum.JUNCTION + + +obstruction = IfcDuctFittingTypeEnum.OBSTRUCTION + + +transition = IfcDuctFittingTypeEnum.TRANSITION + + +userdefined = IfcDuctFittingTypeEnum.USERDEFINED + + +notdefined = IfcDuctFittingTypeEnum.NOTDEFINED + + +IfcDuctSegmentTypeEnum = enum_namespace() + + +rigidsegment = IfcDuctSegmentTypeEnum.RIGIDSEGMENT + + +flexiblesegment = IfcDuctSegmentTypeEnum.FLEXIBLESEGMENT + + +userdefined = IfcDuctSegmentTypeEnum.USERDEFINED + + +notdefined = IfcDuctSegmentTypeEnum.NOTDEFINED + + +IfcDuctSilencerTypeEnum = enum_namespace() + + +flatoval = IfcDuctSilencerTypeEnum.FLATOVAL + + +rectangular = IfcDuctSilencerTypeEnum.RECTANGULAR + + +round = IfcDuctSilencerTypeEnum.ROUND + + +userdefined = IfcDuctSilencerTypeEnum.USERDEFINED + + +notdefined = IfcDuctSilencerTypeEnum.NOTDEFINED + + +IfcEarthworksCutTypeEnum = enum_namespace() + + +trench = IfcEarthworksCutTypeEnum.TRENCH + + +dredging = IfcEarthworksCutTypeEnum.DREDGING + + +excavation = IfcEarthworksCutTypeEnum.EXCAVATION + + +overexcavation = IfcEarthworksCutTypeEnum.OVEREXCAVATION + + +topsoilremoval = IfcEarthworksCutTypeEnum.TOPSOILREMOVAL + + +stepexcavation = IfcEarthworksCutTypeEnum.STEPEXCAVATION + + +pavementmilling = IfcEarthworksCutTypeEnum.PAVEMENTMILLING + + +cut = IfcEarthworksCutTypeEnum.CUT + + +base_excavation = IfcEarthworksCutTypeEnum.BASE_EXCAVATION + + +userdefined = IfcEarthworksCutTypeEnum.USERDEFINED + + +notdefined = IfcEarthworksCutTypeEnum.NOTDEFINED + + +IfcEarthworksFillTypeEnum = enum_namespace() + + +backfill = IfcEarthworksFillTypeEnum.BACKFILL + + +counterweight = IfcEarthworksFillTypeEnum.COUNTERWEIGHT + + +subgrade = IfcEarthworksFillTypeEnum.SUBGRADE + + +embankment = IfcEarthworksFillTypeEnum.EMBANKMENT + + +transitionsection = IfcEarthworksFillTypeEnum.TRANSITIONSECTION + + +subgradebed = IfcEarthworksFillTypeEnum.SUBGRADEBED + + +slopefill = IfcEarthworksFillTypeEnum.SLOPEFILL + + +userdefined = IfcEarthworksFillTypeEnum.USERDEFINED + + +notdefined = IfcEarthworksFillTypeEnum.NOTDEFINED + + +IfcElectricApplianceTypeEnum = enum_namespace() + + +dishwasher = IfcElectricApplianceTypeEnum.DISHWASHER + + +electriccooker = IfcElectricApplianceTypeEnum.ELECTRICCOOKER + + +freestandingelectricheater = IfcElectricApplianceTypeEnum.FREESTANDINGELECTRICHEATER + + +freestandingfan = IfcElectricApplianceTypeEnum.FREESTANDINGFAN + + +freestandingwaterheater = IfcElectricApplianceTypeEnum.FREESTANDINGWATERHEATER + + +freestandingwatercooler = IfcElectricApplianceTypeEnum.FREESTANDINGWATERCOOLER + + +freezer = IfcElectricApplianceTypeEnum.FREEZER + + +fridge_freezer = IfcElectricApplianceTypeEnum.FRIDGE_FREEZER + + +handdryer = IfcElectricApplianceTypeEnum.HANDDRYER + + +kitchenmachine = IfcElectricApplianceTypeEnum.KITCHENMACHINE + + +microwave = IfcElectricApplianceTypeEnum.MICROWAVE + + +photocopier = IfcElectricApplianceTypeEnum.PHOTOCOPIER + + +refrigerator = IfcElectricApplianceTypeEnum.REFRIGERATOR + + +tumbledryer = IfcElectricApplianceTypeEnum.TUMBLEDRYER + + +vendingmachine = IfcElectricApplianceTypeEnum.VENDINGMACHINE + + +washingmachine = IfcElectricApplianceTypeEnum.WASHINGMACHINE + + +userdefined = IfcElectricApplianceTypeEnum.USERDEFINED + + +notdefined = IfcElectricApplianceTypeEnum.NOTDEFINED + + +IfcElectricDistributionBoardTypeEnum = enum_namespace() + + +consumerunit = IfcElectricDistributionBoardTypeEnum.CONSUMERUNIT + + +distributionboard = IfcElectricDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +motorcontrolcentre = IfcElectricDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +switchboard = IfcElectricDistributionBoardTypeEnum.SWITCHBOARD + + +userdefined = IfcElectricDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcElectricDistributionBoardTypeEnum.NOTDEFINED + + +IfcElectricFlowStorageDeviceTypeEnum = enum_namespace() + + +battery = IfcElectricFlowStorageDeviceTypeEnum.BATTERY + + +capacitorbank = IfcElectricFlowStorageDeviceTypeEnum.CAPACITORBANK + + +harmonicfilter = IfcElectricFlowStorageDeviceTypeEnum.HARMONICFILTER + + +inductorbank = IfcElectricFlowStorageDeviceTypeEnum.INDUCTORBANK + + +ups = IfcElectricFlowStorageDeviceTypeEnum.UPS + + +capacitor = IfcElectricFlowStorageDeviceTypeEnum.CAPACITOR + + +compensator = IfcElectricFlowStorageDeviceTypeEnum.COMPENSATOR + + +inductor = IfcElectricFlowStorageDeviceTypeEnum.INDUCTOR + + +recharger = IfcElectricFlowStorageDeviceTypeEnum.RECHARGER + + +userdefined = IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowStorageDeviceTypeEnum.NOTDEFINED + + +IfcElectricFlowTreatmentDeviceTypeEnum = enum_namespace() + + +electronicfilter = IfcElectricFlowTreatmentDeviceTypeEnum.ELECTRONICFILTER + + +userdefined = IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowTreatmentDeviceTypeEnum.NOTDEFINED + + +IfcElectricGeneratorTypeEnum = enum_namespace() + + +chp = IfcElectricGeneratorTypeEnum.CHP + + +enginegenerator = IfcElectricGeneratorTypeEnum.ENGINEGENERATOR + + +standalone = IfcElectricGeneratorTypeEnum.STANDALONE + + +userdefined = IfcElectricGeneratorTypeEnum.USERDEFINED + + +notdefined = IfcElectricGeneratorTypeEnum.NOTDEFINED + + +IfcElectricMotorTypeEnum = enum_namespace() + + +dc = IfcElectricMotorTypeEnum.DC + + +induction = IfcElectricMotorTypeEnum.INDUCTION + + +polyphase = IfcElectricMotorTypeEnum.POLYPHASE + + +reluctancesynchronous = IfcElectricMotorTypeEnum.RELUCTANCESYNCHRONOUS + + +synchronous = IfcElectricMotorTypeEnum.SYNCHRONOUS + + +userdefined = IfcElectricMotorTypeEnum.USERDEFINED + + +notdefined = IfcElectricMotorTypeEnum.NOTDEFINED + + +IfcElectricTimeControlTypeEnum = enum_namespace() + + +timeclock = IfcElectricTimeControlTypeEnum.TIMECLOCK + + +timedelay = IfcElectricTimeControlTypeEnum.TIMEDELAY + + +relay = IfcElectricTimeControlTypeEnum.RELAY + + +userdefined = IfcElectricTimeControlTypeEnum.USERDEFINED + + +notdefined = IfcElectricTimeControlTypeEnum.NOTDEFINED + + +IfcElementAssemblyTypeEnum = enum_namespace() + + +accessory_assembly = IfcElementAssemblyTypeEnum.ACCESSORY_ASSEMBLY + + +arch = IfcElementAssemblyTypeEnum.ARCH + + +beam_grid = IfcElementAssemblyTypeEnum.BEAM_GRID + + +braced_frame = IfcElementAssemblyTypeEnum.BRACED_FRAME + + +girder = IfcElementAssemblyTypeEnum.GIRDER + + +reinforcement_unit = IfcElementAssemblyTypeEnum.REINFORCEMENT_UNIT + + +rigid_frame = IfcElementAssemblyTypeEnum.RIGID_FRAME + + +slab_field = IfcElementAssemblyTypeEnum.SLAB_FIELD + + +truss = IfcElementAssemblyTypeEnum.TRUSS + + +abutment = IfcElementAssemblyTypeEnum.ABUTMENT + + +pier = IfcElementAssemblyTypeEnum.PIER + + +pylon = IfcElementAssemblyTypeEnum.PYLON + + +cross_bracing = IfcElementAssemblyTypeEnum.CROSS_BRACING + + +deck = IfcElementAssemblyTypeEnum.DECK + + +mast = IfcElementAssemblyTypeEnum.MAST + + +signalassembly = IfcElementAssemblyTypeEnum.SIGNALASSEMBLY + + +grid = IfcElementAssemblyTypeEnum.GRID + + +shelter = IfcElementAssemblyTypeEnum.SHELTER + + +supportingassembly = IfcElementAssemblyTypeEnum.SUPPORTINGASSEMBLY + + +suspensionassembly = IfcElementAssemblyTypeEnum.SUSPENSIONASSEMBLY + + +traction_switching_assembly = IfcElementAssemblyTypeEnum.TRACTION_SWITCHING_ASSEMBLY + + +trackpanel = IfcElementAssemblyTypeEnum.TRACKPANEL + + +turnoutpanel = IfcElementAssemblyTypeEnum.TURNOUTPANEL + + +dilatationpanel = IfcElementAssemblyTypeEnum.DILATATIONPANEL + + +rail_mechanical_equipment_assembly = IfcElementAssemblyTypeEnum.RAIL_MECHANICAL_EQUIPMENT_ASSEMBLY + + +entranceworks = IfcElementAssemblyTypeEnum.ENTRANCEWORKS + + +sumpbuster = IfcElementAssemblyTypeEnum.SUMPBUSTER + + +traffic_calming_device = IfcElementAssemblyTypeEnum.TRAFFIC_CALMING_DEVICE + + +userdefined = IfcElementAssemblyTypeEnum.USERDEFINED + + +notdefined = IfcElementAssemblyTypeEnum.NOTDEFINED + + +IfcElementCompositionEnum = enum_namespace() + + +complex = IfcElementCompositionEnum.COMPLEX + + +element = IfcElementCompositionEnum.ELEMENT + + +partial = IfcElementCompositionEnum.PARTIAL + + +IfcEngineTypeEnum = enum_namespace() + + +externalcombustion = IfcEngineTypeEnum.EXTERNALCOMBUSTION + + +internalcombustion = IfcEngineTypeEnum.INTERNALCOMBUSTION + + +userdefined = IfcEngineTypeEnum.USERDEFINED + + +notdefined = IfcEngineTypeEnum.NOTDEFINED + + +IfcEvaporativeCoolerTypeEnum = enum_namespace() + + +directevaporativerandommediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER + + +directevaporativerigidmediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER + + +directevaporativeslingerspackagedaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER + + +directevaporativepackagedrotaryaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER + + +directevaporativeairwasher = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEAIRWASHER + + +indirectevaporativepackageaircooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEPACKAGEAIRCOOLER + + +indirectevaporativewetcoil = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEWETCOIL + + +indirectevaporativecoolingtowerorcoilcooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER + + +indirectdirectcombination = IfcEvaporativeCoolerTypeEnum.INDIRECTDIRECTCOMBINATION + + +userdefined = IfcEvaporativeCoolerTypeEnum.USERDEFINED + + +notdefined = IfcEvaporativeCoolerTypeEnum.NOTDEFINED + + +IfcEvaporatorTypeEnum = enum_namespace() + + +directexpansion = IfcEvaporatorTypeEnum.DIRECTEXPANSION + + +directexpansionshellandtube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONSHELLANDTUBE + + +directexpansiontubeintube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONTUBEINTUBE + + +directexpansionbrazedplate = IfcEvaporatorTypeEnum.DIRECTEXPANSIONBRAZEDPLATE + + +floodedshellandtube = IfcEvaporatorTypeEnum.FLOODEDSHELLANDTUBE + + +shellandcoil = IfcEvaporatorTypeEnum.SHELLANDCOIL + + +userdefined = IfcEvaporatorTypeEnum.USERDEFINED + + +notdefined = IfcEvaporatorTypeEnum.NOTDEFINED + + +IfcEventTriggerTypeEnum = enum_namespace() + + +eventrule = IfcEventTriggerTypeEnum.EVENTRULE + + +eventmessage = IfcEventTriggerTypeEnum.EVENTMESSAGE + + +eventtime = IfcEventTriggerTypeEnum.EVENTTIME + + +eventcomplex = IfcEventTriggerTypeEnum.EVENTCOMPLEX + + +userdefined = IfcEventTriggerTypeEnum.USERDEFINED + + +notdefined = IfcEventTriggerTypeEnum.NOTDEFINED + + +IfcEventTypeEnum = enum_namespace() + + +startevent = IfcEventTypeEnum.STARTEVENT + + +endevent = IfcEventTypeEnum.ENDEVENT + + +intermediateevent = IfcEventTypeEnum.INTERMEDIATEEVENT + + +userdefined = IfcEventTypeEnum.USERDEFINED + + +notdefined = IfcEventTypeEnum.NOTDEFINED + + +IfcExternalSpatialElementTypeEnum = enum_namespace() + + +external = IfcExternalSpatialElementTypeEnum.EXTERNAL + + +external_earth = IfcExternalSpatialElementTypeEnum.EXTERNAL_EARTH + + +external_water = IfcExternalSpatialElementTypeEnum.EXTERNAL_WATER + + +external_fire = IfcExternalSpatialElementTypeEnum.EXTERNAL_FIRE + + +userdefined = IfcExternalSpatialElementTypeEnum.USERDEFINED + + +notdefined = IfcExternalSpatialElementTypeEnum.NOTDEFINED + + +IfcFacilityPartCommonTypeEnum = enum_namespace() + + +segment = IfcFacilityPartCommonTypeEnum.SEGMENT + + +aboveground = IfcFacilityPartCommonTypeEnum.ABOVEGROUND + + +junction = IfcFacilityPartCommonTypeEnum.JUNCTION + + +levelcrossing = IfcFacilityPartCommonTypeEnum.LEVELCROSSING + + +belowground = IfcFacilityPartCommonTypeEnum.BELOWGROUND + + +substructure = IfcFacilityPartCommonTypeEnum.SUBSTRUCTURE + + +terminal = IfcFacilityPartCommonTypeEnum.TERMINAL + + +superstructure = IfcFacilityPartCommonTypeEnum.SUPERSTRUCTURE + + +userdefined = IfcFacilityPartCommonTypeEnum.USERDEFINED + + +notdefined = IfcFacilityPartCommonTypeEnum.NOTDEFINED + + +IfcFacilityUsageEnum = enum_namespace() + + +lateral = IfcFacilityUsageEnum.LATERAL + + +region = IfcFacilityUsageEnum.REGION + + +vertical = IfcFacilityUsageEnum.VERTICAL + + +longitudinal = IfcFacilityUsageEnum.LONGITUDINAL + + +userdefined = IfcFacilityUsageEnum.USERDEFINED + + +notdefined = IfcFacilityUsageEnum.NOTDEFINED + + +IfcFanTypeEnum = enum_namespace() + + +centrifugalforwardcurved = IfcFanTypeEnum.CENTRIFUGALFORWARDCURVED + + +centrifugalradial = IfcFanTypeEnum.CENTRIFUGALRADIAL + + +centrifugalbackwardinclinedcurved = IfcFanTypeEnum.CENTRIFUGALBACKWARDINCLINEDCURVED + + +centrifugalairfoil = IfcFanTypeEnum.CENTRIFUGALAIRFOIL + + +tubeaxial = IfcFanTypeEnum.TUBEAXIAL + + +vaneaxial = IfcFanTypeEnum.VANEAXIAL + + +propelloraxial = IfcFanTypeEnum.PROPELLORAXIAL + + +userdefined = IfcFanTypeEnum.USERDEFINED + + +notdefined = IfcFanTypeEnum.NOTDEFINED + + +IfcFastenerTypeEnum = enum_namespace() + + +glue = IfcFastenerTypeEnum.GLUE + + +mortar = IfcFastenerTypeEnum.MORTAR + + +weld = IfcFastenerTypeEnum.WELD + + +userdefined = IfcFastenerTypeEnum.USERDEFINED + + +notdefined = IfcFastenerTypeEnum.NOTDEFINED + + +IfcFilterTypeEnum = enum_namespace() + + +airparticlefilter = IfcFilterTypeEnum.AIRPARTICLEFILTER + + +compressedairfilter = IfcFilterTypeEnum.COMPRESSEDAIRFILTER + + +odorfilter = IfcFilterTypeEnum.ODORFILTER + + +oilfilter = IfcFilterTypeEnum.OILFILTER + + +strainer = IfcFilterTypeEnum.STRAINER + + +waterfilter = IfcFilterTypeEnum.WATERFILTER + + +userdefined = IfcFilterTypeEnum.USERDEFINED + + +notdefined = IfcFilterTypeEnum.NOTDEFINED + + +IfcFireSuppressionTerminalTypeEnum = enum_namespace() + + +breechinginlet = IfcFireSuppressionTerminalTypeEnum.BREECHINGINLET + + +firehydrant = IfcFireSuppressionTerminalTypeEnum.FIREHYDRANT + + +hosereel = IfcFireSuppressionTerminalTypeEnum.HOSEREEL + + +sprinkler = IfcFireSuppressionTerminalTypeEnum.SPRINKLER + + +sprinklerdeflector = IfcFireSuppressionTerminalTypeEnum.SPRINKLERDEFLECTOR + + +firemonitor = IfcFireSuppressionTerminalTypeEnum.FIREMONITOR + + +userdefined = IfcFireSuppressionTerminalTypeEnum.USERDEFINED + + +notdefined = IfcFireSuppressionTerminalTypeEnum.NOTDEFINED + + +IfcFlowDirectionEnum = enum_namespace() + + +source = IfcFlowDirectionEnum.SOURCE + + +sink = IfcFlowDirectionEnum.SINK + + +sourceandsink = IfcFlowDirectionEnum.SOURCEANDSINK + + +notdefined = IfcFlowDirectionEnum.NOTDEFINED + + +IfcFlowInstrumentTypeEnum = enum_namespace() + + +pressuregauge = IfcFlowInstrumentTypeEnum.PRESSUREGAUGE + + +thermometer = IfcFlowInstrumentTypeEnum.THERMOMETER + + +ammeter = IfcFlowInstrumentTypeEnum.AMMETER + + +frequencymeter = IfcFlowInstrumentTypeEnum.FREQUENCYMETER + + +powerfactormeter = IfcFlowInstrumentTypeEnum.POWERFACTORMETER + + +phaseanglemeter = IfcFlowInstrumentTypeEnum.PHASEANGLEMETER + + +voltmeter_peak = IfcFlowInstrumentTypeEnum.VOLTMETER_PEAK + + +voltmeter_rms = IfcFlowInstrumentTypeEnum.VOLTMETER_RMS + + +combined = IfcFlowInstrumentTypeEnum.COMBINED + + +voltmeter = IfcFlowInstrumentTypeEnum.VOLTMETER + + +userdefined = IfcFlowInstrumentTypeEnum.USERDEFINED + + +notdefined = IfcFlowInstrumentTypeEnum.NOTDEFINED + + +IfcFlowMeterTypeEnum = enum_namespace() + + +energymeter = IfcFlowMeterTypeEnum.ENERGYMETER + + +gasmeter = IfcFlowMeterTypeEnum.GASMETER + + +oilmeter = IfcFlowMeterTypeEnum.OILMETER + + +watermeter = IfcFlowMeterTypeEnum.WATERMETER + + +userdefined = IfcFlowMeterTypeEnum.USERDEFINED + + +notdefined = IfcFlowMeterTypeEnum.NOTDEFINED + + +IfcFootingTypeEnum = enum_namespace() + + +caisson_foundation = IfcFootingTypeEnum.CAISSON_FOUNDATION + + +footing_beam = IfcFootingTypeEnum.FOOTING_BEAM + + +pad_footing = IfcFootingTypeEnum.PAD_FOOTING + + +pile_cap = IfcFootingTypeEnum.PILE_CAP + + +strip_footing = IfcFootingTypeEnum.STRIP_FOOTING + + +userdefined = IfcFootingTypeEnum.USERDEFINED + + +notdefined = IfcFootingTypeEnum.NOTDEFINED + + +IfcFurnitureTypeEnum = enum_namespace() + + +chair = IfcFurnitureTypeEnum.CHAIR + + +table = IfcFurnitureTypeEnum.TABLE + + +desk = IfcFurnitureTypeEnum.DESK + + +bed = IfcFurnitureTypeEnum.BED + + +filecabinet = IfcFurnitureTypeEnum.FILECABINET + + +shelf = IfcFurnitureTypeEnum.SHELF + + +sofa = IfcFurnitureTypeEnum.SOFA + + +technicalcabinet = IfcFurnitureTypeEnum.TECHNICALCABINET + + +userdefined = IfcFurnitureTypeEnum.USERDEFINED + + +notdefined = IfcFurnitureTypeEnum.NOTDEFINED + + +IfcGeographicElementTypeEnum = enum_namespace() + + +terrain = IfcGeographicElementTypeEnum.TERRAIN + + +soil_boring_point = IfcGeographicElementTypeEnum.SOIL_BORING_POINT + + +userdefined = IfcGeographicElementTypeEnum.USERDEFINED + + +notdefined = IfcGeographicElementTypeEnum.NOTDEFINED + + +IfcGeometricProjectionEnum = enum_namespace() + + +graph_view = IfcGeometricProjectionEnum.GRAPH_VIEW + + +sketch_view = IfcGeometricProjectionEnum.SKETCH_VIEW + + +model_view = IfcGeometricProjectionEnum.MODEL_VIEW + + +plan_view = IfcGeometricProjectionEnum.PLAN_VIEW + + +reflected_plan_view = IfcGeometricProjectionEnum.REFLECTED_PLAN_VIEW + + +section_view = IfcGeometricProjectionEnum.SECTION_VIEW + + +elevation_view = IfcGeometricProjectionEnum.ELEVATION_VIEW + + +userdefined = IfcGeometricProjectionEnum.USERDEFINED + + +notdefined = IfcGeometricProjectionEnum.NOTDEFINED + + +IfcGlobalOrLocalEnum = enum_namespace() + + +global_coords = IfcGlobalOrLocalEnum.GLOBAL_COORDS + + +local_coords = IfcGlobalOrLocalEnum.LOCAL_COORDS + + +IfcGridTypeEnum = enum_namespace() + + +rectangular = IfcGridTypeEnum.RECTANGULAR + + +radial = IfcGridTypeEnum.RADIAL + + +triangular = IfcGridTypeEnum.TRIANGULAR + + +irregular = IfcGridTypeEnum.IRREGULAR + + +userdefined = IfcGridTypeEnum.USERDEFINED + + +notdefined = IfcGridTypeEnum.NOTDEFINED + + +IfcHeatExchangerTypeEnum = enum_namespace() + + +plate = IfcHeatExchangerTypeEnum.PLATE + + +shellandtube = IfcHeatExchangerTypeEnum.SHELLANDTUBE + + +turnoutheating = IfcHeatExchangerTypeEnum.TURNOUTHEATING + + +userdefined = IfcHeatExchangerTypeEnum.USERDEFINED + + +notdefined = IfcHeatExchangerTypeEnum.NOTDEFINED + + +IfcHumidifierTypeEnum = enum_namespace() + + +steaminjection = IfcHumidifierTypeEnum.STEAMINJECTION + + +adiabaticairwasher = IfcHumidifierTypeEnum.ADIABATICAIRWASHER + + +adiabaticpan = IfcHumidifierTypeEnum.ADIABATICPAN + + +adiabaticwettedelement = IfcHumidifierTypeEnum.ADIABATICWETTEDELEMENT + + +adiabaticatomizing = IfcHumidifierTypeEnum.ADIABATICATOMIZING + + +adiabaticultrasonic = IfcHumidifierTypeEnum.ADIABATICULTRASONIC + + +adiabaticrigidmedia = IfcHumidifierTypeEnum.ADIABATICRIGIDMEDIA + + +adiabaticcompressedairnozzle = IfcHumidifierTypeEnum.ADIABATICCOMPRESSEDAIRNOZZLE + + +assistedelectric = IfcHumidifierTypeEnum.ASSISTEDELECTRIC + + +assistednaturalgas = IfcHumidifierTypeEnum.ASSISTEDNATURALGAS + + +assistedpropane = IfcHumidifierTypeEnum.ASSISTEDPROPANE + + +assistedbutane = IfcHumidifierTypeEnum.ASSISTEDBUTANE + + +assistedsteam = IfcHumidifierTypeEnum.ASSISTEDSTEAM + + +userdefined = IfcHumidifierTypeEnum.USERDEFINED + + +notdefined = IfcHumidifierTypeEnum.NOTDEFINED + + +IfcImpactProtectionDeviceTypeEnum = enum_namespace() + + +crashcushion = IfcImpactProtectionDeviceTypeEnum.CRASHCUSHION + + +dampingsystem = IfcImpactProtectionDeviceTypeEnum.DAMPINGSYSTEM + + +fender = IfcImpactProtectionDeviceTypeEnum.FENDER + + +bumper = IfcImpactProtectionDeviceTypeEnum.BUMPER + + +userdefined = IfcImpactProtectionDeviceTypeEnum.USERDEFINED + + +notdefined = IfcImpactProtectionDeviceTypeEnum.NOTDEFINED + + +IfcInterceptorTypeEnum = enum_namespace() + + +cyclonic = IfcInterceptorTypeEnum.CYCLONIC + + +grease = IfcInterceptorTypeEnum.GREASE + + +oil = IfcInterceptorTypeEnum.OIL + + +petrol = IfcInterceptorTypeEnum.PETROL + + +userdefined = IfcInterceptorTypeEnum.USERDEFINED + + +notdefined = IfcInterceptorTypeEnum.NOTDEFINED + + +IfcInternalOrExternalEnum = enum_namespace() + + +internal = IfcInternalOrExternalEnum.INTERNAL + + +external = IfcInternalOrExternalEnum.EXTERNAL + + +external_earth = IfcInternalOrExternalEnum.EXTERNAL_EARTH + + +external_water = IfcInternalOrExternalEnum.EXTERNAL_WATER + + +external_fire = IfcInternalOrExternalEnum.EXTERNAL_FIRE + + +notdefined = IfcInternalOrExternalEnum.NOTDEFINED + + +IfcInventoryTypeEnum = enum_namespace() + + +assetinventory = IfcInventoryTypeEnum.ASSETINVENTORY + + +spaceinventory = IfcInventoryTypeEnum.SPACEINVENTORY + + +furnitureinventory = IfcInventoryTypeEnum.FURNITUREINVENTORY + + +userdefined = IfcInventoryTypeEnum.USERDEFINED + + +notdefined = IfcInventoryTypeEnum.NOTDEFINED + + +IfcJunctionBoxTypeEnum = enum_namespace() + + +data = IfcJunctionBoxTypeEnum.DATA + + +power = IfcJunctionBoxTypeEnum.POWER + + +userdefined = IfcJunctionBoxTypeEnum.USERDEFINED + + +notdefined = IfcJunctionBoxTypeEnum.NOTDEFINED + + +IfcKnotType = enum_namespace() + + +uniform_knots = IfcKnotType.UNIFORM_KNOTS + + +quasi_uniform_knots = IfcKnotType.QUASI_UNIFORM_KNOTS + + +piecewise_bezier_knots = IfcKnotType.PIECEWISE_BEZIER_KNOTS + + +unspecified = IfcKnotType.UNSPECIFIED + + +IfcLaborResourceTypeEnum = enum_namespace() + + +administration = IfcLaborResourceTypeEnum.ADMINISTRATION + + +carpentry = IfcLaborResourceTypeEnum.CARPENTRY + + +cleaning = IfcLaborResourceTypeEnum.CLEANING + + +concrete = IfcLaborResourceTypeEnum.CONCRETE + + +drywall = IfcLaborResourceTypeEnum.DRYWALL + + +electric = IfcLaborResourceTypeEnum.ELECTRIC + + +finishing = IfcLaborResourceTypeEnum.FINISHING + + +flooring = IfcLaborResourceTypeEnum.FLOORING + + +general = IfcLaborResourceTypeEnum.GENERAL + + +hvac = IfcLaborResourceTypeEnum.HVAC + + +landscaping = IfcLaborResourceTypeEnum.LANDSCAPING + + +masonry = IfcLaborResourceTypeEnum.MASONRY + + +painting = IfcLaborResourceTypeEnum.PAINTING + + +paving = IfcLaborResourceTypeEnum.PAVING + + +plumbing = IfcLaborResourceTypeEnum.PLUMBING + + +roofing = IfcLaborResourceTypeEnum.ROOFING + + +sitegrading = IfcLaborResourceTypeEnum.SITEGRADING + + +steelwork = IfcLaborResourceTypeEnum.STEELWORK + + +surveying = IfcLaborResourceTypeEnum.SURVEYING + + +userdefined = IfcLaborResourceTypeEnum.USERDEFINED + + +notdefined = IfcLaborResourceTypeEnum.NOTDEFINED + + +IfcLampTypeEnum = enum_namespace() + + +compactfluorescent = IfcLampTypeEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLampTypeEnum.FLUORESCENT + + +halogen = IfcLampTypeEnum.HALOGEN + + +highpressuremercury = IfcLampTypeEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLampTypeEnum.HIGHPRESSURESODIUM + + +led = IfcLampTypeEnum.LED + + +metalhalide = IfcLampTypeEnum.METALHALIDE + + +oled = IfcLampTypeEnum.OLED + + +tungstenfilament = IfcLampTypeEnum.TUNGSTENFILAMENT + + +userdefined = IfcLampTypeEnum.USERDEFINED + + +notdefined = IfcLampTypeEnum.NOTDEFINED + + +IfcLayerSetDirectionEnum = enum_namespace() + + +axis1 = IfcLayerSetDirectionEnum.AXIS1 + + +axis2 = IfcLayerSetDirectionEnum.AXIS2 + + +axis3 = IfcLayerSetDirectionEnum.AXIS3 + + +IfcLightDistributionCurveEnum = enum_namespace() + + +type_a = IfcLightDistributionCurveEnum.TYPE_A + + +type_b = IfcLightDistributionCurveEnum.TYPE_B + + +type_c = IfcLightDistributionCurveEnum.TYPE_C + + +notdefined = IfcLightDistributionCurveEnum.NOTDEFINED + + +IfcLightEmissionSourceEnum = enum_namespace() + + +compactfluorescent = IfcLightEmissionSourceEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLightEmissionSourceEnum.FLUORESCENT + + +highpressuremercury = IfcLightEmissionSourceEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLightEmissionSourceEnum.HIGHPRESSURESODIUM + + +lightemittingdiode = IfcLightEmissionSourceEnum.LIGHTEMITTINGDIODE + + +lowpressuresodium = IfcLightEmissionSourceEnum.LOWPRESSURESODIUM + + +lowvoltagehalogen = IfcLightEmissionSourceEnum.LOWVOLTAGEHALOGEN + + +mainvoltagehalogen = IfcLightEmissionSourceEnum.MAINVOLTAGEHALOGEN + + +metalhalide = IfcLightEmissionSourceEnum.METALHALIDE + + +tungstenfilament = IfcLightEmissionSourceEnum.TUNGSTENFILAMENT + + +notdefined = IfcLightEmissionSourceEnum.NOTDEFINED + + +IfcLightFixtureTypeEnum = enum_namespace() + + +pointsource = IfcLightFixtureTypeEnum.POINTSOURCE + + +directionsource = IfcLightFixtureTypeEnum.DIRECTIONSOURCE + + +securitylighting = IfcLightFixtureTypeEnum.SECURITYLIGHTING + + +userdefined = IfcLightFixtureTypeEnum.USERDEFINED + + +notdefined = IfcLightFixtureTypeEnum.NOTDEFINED + + +IfcLiquidTerminalTypeEnum = enum_namespace() + + +loadingarm = IfcLiquidTerminalTypeEnum.LOADINGARM + + +hosereel = IfcLiquidTerminalTypeEnum.HOSEREEL + + +userdefined = IfcLiquidTerminalTypeEnum.USERDEFINED + + +notdefined = IfcLiquidTerminalTypeEnum.NOTDEFINED + + +IfcLoadGroupTypeEnum = enum_namespace() + + +load_group = IfcLoadGroupTypeEnum.LOAD_GROUP + + +load_case = IfcLoadGroupTypeEnum.LOAD_CASE + + +load_combination = IfcLoadGroupTypeEnum.LOAD_COMBINATION + + +userdefined = IfcLoadGroupTypeEnum.USERDEFINED + + +notdefined = IfcLoadGroupTypeEnum.NOTDEFINED + + +IfcLogicalOperatorEnum = enum_namespace() + + +logicaland = IfcLogicalOperatorEnum.LOGICALAND + + +logicalor = IfcLogicalOperatorEnum.LOGICALOR + + +logicalxor = IfcLogicalOperatorEnum.LOGICALXOR + + +logicalnotand = IfcLogicalOperatorEnum.LOGICALNOTAND + + +logicalnotor = IfcLogicalOperatorEnum.LOGICALNOTOR + + +IfcMarineFacilityTypeEnum = enum_namespace() + + +canal = IfcMarineFacilityTypeEnum.CANAL + + +waterwayshiplift = IfcMarineFacilityTypeEnum.WATERWAYSHIPLIFT + + +revetment = IfcMarineFacilityTypeEnum.REVETMENT + + +launchrecovery = IfcMarineFacilityTypeEnum.LAUNCHRECOVERY + + +marinedefence = IfcMarineFacilityTypeEnum.MARINEDEFENCE + + +hydrolift = IfcMarineFacilityTypeEnum.HYDROLIFT + + +shipyard = IfcMarineFacilityTypeEnum.SHIPYARD + + +shiplift = IfcMarineFacilityTypeEnum.SHIPLIFT + + +port = IfcMarineFacilityTypeEnum.PORT + + +quay = IfcMarineFacilityTypeEnum.QUAY + + +floatingdock = IfcMarineFacilityTypeEnum.FLOATINGDOCK + + +navigationalchannel = IfcMarineFacilityTypeEnum.NAVIGATIONALCHANNEL + + +breakwater = IfcMarineFacilityTypeEnum.BREAKWATER + + +drydock = IfcMarineFacilityTypeEnum.DRYDOCK + + +jetty = IfcMarineFacilityTypeEnum.JETTY + + +shiplock = IfcMarineFacilityTypeEnum.SHIPLOCK + + +barrierbeach = IfcMarineFacilityTypeEnum.BARRIERBEACH + + +slipway = IfcMarineFacilityTypeEnum.SLIPWAY + + +waterway = IfcMarineFacilityTypeEnum.WATERWAY + + +userdefined = IfcMarineFacilityTypeEnum.USERDEFINED + + +notdefined = IfcMarineFacilityTypeEnum.NOTDEFINED + + +IfcMarinePartTypeEnum = enum_namespace() + + +crest = IfcMarinePartTypeEnum.CREST + + +manufacturing = IfcMarinePartTypeEnum.MANUFACTURING + + +lowwaterline = IfcMarinePartTypeEnum.LOWWATERLINE + + +core = IfcMarinePartTypeEnum.CORE + + +waterfield = IfcMarinePartTypeEnum.WATERFIELD + + +cill_level = IfcMarinePartTypeEnum.CILL_LEVEL + + +berthingstructure = IfcMarinePartTypeEnum.BERTHINGSTRUCTURE + + +copelevel = IfcMarinePartTypeEnum.COPELEVEL + + +chamber = IfcMarinePartTypeEnum.CHAMBER + + +storagearea = IfcMarinePartTypeEnum.STORAGEAREA + + +approachchannel = IfcMarinePartTypeEnum.APPROACHCHANNEL + + +vehicleservicing = IfcMarinePartTypeEnum.VEHICLESERVICING + + +shiptransfer = IfcMarinePartTypeEnum.SHIPTRANSFER + + +gatehead = IfcMarinePartTypeEnum.GATEHEAD + + +gudingstructure = IfcMarinePartTypeEnum.GUDINGSTRUCTURE + + +belowwaterline = IfcMarinePartTypeEnum.BELOWWATERLINE + + +weatherside = IfcMarinePartTypeEnum.WEATHERSIDE + + +landfield = IfcMarinePartTypeEnum.LANDFIELD + + +protection = IfcMarinePartTypeEnum.PROTECTION + + +leewardside = IfcMarinePartTypeEnum.LEEWARDSIDE + + +abovewaterline = IfcMarinePartTypeEnum.ABOVEWATERLINE + + +anchorage = IfcMarinePartTypeEnum.ANCHORAGE + + +navigationalarea = IfcMarinePartTypeEnum.NAVIGATIONALAREA + + +highwaterline = IfcMarinePartTypeEnum.HIGHWATERLINE + + +userdefined = IfcMarinePartTypeEnum.USERDEFINED + + +notdefined = IfcMarinePartTypeEnum.NOTDEFINED + + +IfcMechanicalFastenerTypeEnum = enum_namespace() + + +anchorbolt = IfcMechanicalFastenerTypeEnum.ANCHORBOLT + + +bolt = IfcMechanicalFastenerTypeEnum.BOLT + + +dowel = IfcMechanicalFastenerTypeEnum.DOWEL + + +nail = IfcMechanicalFastenerTypeEnum.NAIL + + +nailplate = IfcMechanicalFastenerTypeEnum.NAILPLATE + + +rivet = IfcMechanicalFastenerTypeEnum.RIVET + + +screw = IfcMechanicalFastenerTypeEnum.SCREW + + +shearconnector = IfcMechanicalFastenerTypeEnum.SHEARCONNECTOR + + +staple = IfcMechanicalFastenerTypeEnum.STAPLE + + +studshearconnector = IfcMechanicalFastenerTypeEnum.STUDSHEARCONNECTOR + + +coupler = IfcMechanicalFastenerTypeEnum.COUPLER + + +railjoint = IfcMechanicalFastenerTypeEnum.RAILJOINT + + +railfastening = IfcMechanicalFastenerTypeEnum.RAILFASTENING + + +chain = IfcMechanicalFastenerTypeEnum.CHAIN + + +rope = IfcMechanicalFastenerTypeEnum.ROPE + + +userdefined = IfcMechanicalFastenerTypeEnum.USERDEFINED + + +notdefined = IfcMechanicalFastenerTypeEnum.NOTDEFINED + + +IfcMedicalDeviceTypeEnum = enum_namespace() + + +airstation = IfcMedicalDeviceTypeEnum.AIRSTATION + + +feedairunit = IfcMedicalDeviceTypeEnum.FEEDAIRUNIT + + +oxygengenerator = IfcMedicalDeviceTypeEnum.OXYGENGENERATOR + + +oxygenplant = IfcMedicalDeviceTypeEnum.OXYGENPLANT + + +vacuumstation = IfcMedicalDeviceTypeEnum.VACUUMSTATION + + +userdefined = IfcMedicalDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMedicalDeviceTypeEnum.NOTDEFINED + + +IfcMemberTypeEnum = enum_namespace() + + +brace = IfcMemberTypeEnum.BRACE + + +chord = IfcMemberTypeEnum.CHORD + + +collar = IfcMemberTypeEnum.COLLAR + + +member = IfcMemberTypeEnum.MEMBER + + +mullion = IfcMemberTypeEnum.MULLION + + +plate = IfcMemberTypeEnum.PLATE + + +post = IfcMemberTypeEnum.POST + + +purlin = IfcMemberTypeEnum.PURLIN + + +rafter = IfcMemberTypeEnum.RAFTER + + +stringer = IfcMemberTypeEnum.STRINGER + + +strut = IfcMemberTypeEnum.STRUT + + +stud = IfcMemberTypeEnum.STUD + + +stiffening_rib = IfcMemberTypeEnum.STIFFENING_RIB + + +arch_segment = IfcMemberTypeEnum.ARCH_SEGMENT + + +suspension_cable = IfcMemberTypeEnum.SUSPENSION_CABLE + + +suspender = IfcMemberTypeEnum.SUSPENDER + + +stay_cable = IfcMemberTypeEnum.STAY_CABLE + + +structuralcable = IfcMemberTypeEnum.STRUCTURALCABLE + + +tiebar = IfcMemberTypeEnum.TIEBAR + + +userdefined = IfcMemberTypeEnum.USERDEFINED + + +notdefined = IfcMemberTypeEnum.NOTDEFINED + + +IfcMobileTelecommunicationsApplianceTypeEnum = enum_namespace() + + +e_utran_node_b = IfcMobileTelecommunicationsApplianceTypeEnum.E_UTRAN_NODE_B + + +remoteradiounit = IfcMobileTelecommunicationsApplianceTypeEnum.REMOTERADIOUNIT + + +accesspoint = IfcMobileTelecommunicationsApplianceTypeEnum.ACCESSPOINT + + +basetransceiverstation = IfcMobileTelecommunicationsApplianceTypeEnum.BASETRANSCEIVERSTATION + + +remoteunit = IfcMobileTelecommunicationsApplianceTypeEnum.REMOTEUNIT + + +basebandunit = IfcMobileTelecommunicationsApplianceTypeEnum.BASEBANDUNIT + + +masterunit = IfcMobileTelecommunicationsApplianceTypeEnum.MASTERUNIT + + +gateway_gprs_support_node = IfcMobileTelecommunicationsApplianceTypeEnum.GATEWAY_GPRS_SUPPORT_NODE + + +subscriberserver = IfcMobileTelecommunicationsApplianceTypeEnum.SUBSCRIBERSERVER + + +mobileswitchingcenter = IfcMobileTelecommunicationsApplianceTypeEnum.MOBILESWITCHINGCENTER + + +mscserver = IfcMobileTelecommunicationsApplianceTypeEnum.MSCSERVER + + +packetcontrolunit = IfcMobileTelecommunicationsApplianceTypeEnum.PACKETCONTROLUNIT + + +service_gprs_support_node = IfcMobileTelecommunicationsApplianceTypeEnum.SERVICE_GPRS_SUPPORT_NODE + + +userdefined = IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcMobileTelecommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcMooringDeviceTypeEnum = enum_namespace() + + +linetensioner = IfcMooringDeviceTypeEnum.LINETENSIONER + + +magneticdevice = IfcMooringDeviceTypeEnum.MAGNETICDEVICE + + +mooringhooks = IfcMooringDeviceTypeEnum.MOORINGHOOKS + + +vacuumdevice = IfcMooringDeviceTypeEnum.VACUUMDEVICE + + +bollard = IfcMooringDeviceTypeEnum.BOLLARD + + +userdefined = IfcMooringDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMooringDeviceTypeEnum.NOTDEFINED + + +IfcMotorConnectionTypeEnum = enum_namespace() + + +beltdrive = IfcMotorConnectionTypeEnum.BELTDRIVE + + +coupling = IfcMotorConnectionTypeEnum.COUPLING + + +directdrive = IfcMotorConnectionTypeEnum.DIRECTDRIVE + + +userdefined = IfcMotorConnectionTypeEnum.USERDEFINED + + +notdefined = IfcMotorConnectionTypeEnum.NOTDEFINED + + +IfcNavigationElementTypeEnum = enum_namespace() + + +beacon = IfcNavigationElementTypeEnum.BEACON + + +buoy = IfcNavigationElementTypeEnum.BUOY + + +userdefined = IfcNavigationElementTypeEnum.USERDEFINED + + +notdefined = IfcNavigationElementTypeEnum.NOTDEFINED + + +IfcObjectTypeEnum = enum_namespace() + + +product = IfcObjectTypeEnum.PRODUCT + + +process = IfcObjectTypeEnum.PROCESS + + +control = IfcObjectTypeEnum.CONTROL + + +resource = IfcObjectTypeEnum.RESOURCE + + +actor = IfcObjectTypeEnum.ACTOR + + +group = IfcObjectTypeEnum.GROUP + + +project = IfcObjectTypeEnum.PROJECT + + +notdefined = IfcObjectTypeEnum.NOTDEFINED + + +IfcObjectiveEnum = enum_namespace() + + +codecompliance = IfcObjectiveEnum.CODECOMPLIANCE + + +codewaiver = IfcObjectiveEnum.CODEWAIVER + + +designintent = IfcObjectiveEnum.DESIGNINTENT + + +external = IfcObjectiveEnum.EXTERNAL + + +healthandsafety = IfcObjectiveEnum.HEALTHANDSAFETY + + +mergeconflict = IfcObjectiveEnum.MERGECONFLICT + + +modelview = IfcObjectiveEnum.MODELVIEW + + +parameter = IfcObjectiveEnum.PARAMETER + + +requirement = IfcObjectiveEnum.REQUIREMENT + + +specification = IfcObjectiveEnum.SPECIFICATION + + +triggercondition = IfcObjectiveEnum.TRIGGERCONDITION + + +userdefined = IfcObjectiveEnum.USERDEFINED + + +notdefined = IfcObjectiveEnum.NOTDEFINED + + +IfcOccupantTypeEnum = enum_namespace() + + +assignee = IfcOccupantTypeEnum.ASSIGNEE + + +assignor = IfcOccupantTypeEnum.ASSIGNOR + + +lessee = IfcOccupantTypeEnum.LESSEE + + +lessor = IfcOccupantTypeEnum.LESSOR + + +lettingagent = IfcOccupantTypeEnum.LETTINGAGENT + + +owner = IfcOccupantTypeEnum.OWNER + + +tenant = IfcOccupantTypeEnum.TENANT + + +userdefined = IfcOccupantTypeEnum.USERDEFINED + + +notdefined = IfcOccupantTypeEnum.NOTDEFINED + + +IfcOpeningElementTypeEnum = enum_namespace() + + +opening = IfcOpeningElementTypeEnum.OPENING + + +recess = IfcOpeningElementTypeEnum.RECESS + + +userdefined = IfcOpeningElementTypeEnum.USERDEFINED + + +notdefined = IfcOpeningElementTypeEnum.NOTDEFINED + + +IfcOutletTypeEnum = enum_namespace() + + +audiovisualoutlet = IfcOutletTypeEnum.AUDIOVISUALOUTLET + + +communicationsoutlet = IfcOutletTypeEnum.COMMUNICATIONSOUTLET + + +poweroutlet = IfcOutletTypeEnum.POWEROUTLET + + +dataoutlet = IfcOutletTypeEnum.DATAOUTLET + + +telephoneoutlet = IfcOutletTypeEnum.TELEPHONEOUTLET + + +userdefined = IfcOutletTypeEnum.USERDEFINED + + +notdefined = IfcOutletTypeEnum.NOTDEFINED + + +IfcPavementTypeEnum = enum_namespace() + + +flexible = IfcPavementTypeEnum.FLEXIBLE + + +rigid = IfcPavementTypeEnum.RIGID + + +userdefined = IfcPavementTypeEnum.USERDEFINED + + +notdefined = IfcPavementTypeEnum.NOTDEFINED + + +IfcPerformanceHistoryTypeEnum = enum_namespace() + + +userdefined = IfcPerformanceHistoryTypeEnum.USERDEFINED + + +notdefined = IfcPerformanceHistoryTypeEnum.NOTDEFINED + + +IfcPermeableCoveringOperationEnum = enum_namespace() + + +grill = IfcPermeableCoveringOperationEnum.GRILL + + +louver = IfcPermeableCoveringOperationEnum.LOUVER + + +screen = IfcPermeableCoveringOperationEnum.SCREEN + + +userdefined = IfcPermeableCoveringOperationEnum.USERDEFINED + + +notdefined = IfcPermeableCoveringOperationEnum.NOTDEFINED + + +IfcPermitTypeEnum = enum_namespace() + + +access = IfcPermitTypeEnum.ACCESS + + +building = IfcPermitTypeEnum.BUILDING + + +work = IfcPermitTypeEnum.WORK + + +userdefined = IfcPermitTypeEnum.USERDEFINED + + +notdefined = IfcPermitTypeEnum.NOTDEFINED + + +IfcPhysicalOrVirtualEnum = enum_namespace() + + +physical = IfcPhysicalOrVirtualEnum.PHYSICAL + + +virtual = IfcPhysicalOrVirtualEnum.VIRTUAL + + +notdefined = IfcPhysicalOrVirtualEnum.NOTDEFINED + + +IfcPileConstructionEnum = enum_namespace() + + +cast_in_place = IfcPileConstructionEnum.CAST_IN_PLACE + + +composite = IfcPileConstructionEnum.COMPOSITE + + +precast_concrete = IfcPileConstructionEnum.PRECAST_CONCRETE + + +prefab_steel = IfcPileConstructionEnum.PREFAB_STEEL + + +userdefined = IfcPileConstructionEnum.USERDEFINED + + +notdefined = IfcPileConstructionEnum.NOTDEFINED + + +IfcPileTypeEnum = enum_namespace() + + +bored = IfcPileTypeEnum.BORED + + +driven = IfcPileTypeEnum.DRIVEN + + +jetgrouting = IfcPileTypeEnum.JETGROUTING + + +cohesion = IfcPileTypeEnum.COHESION + + +friction = IfcPileTypeEnum.FRICTION + + +support = IfcPileTypeEnum.SUPPORT + + +userdefined = IfcPileTypeEnum.USERDEFINED + + +notdefined = IfcPileTypeEnum.NOTDEFINED + + +IfcPipeFittingTypeEnum = enum_namespace() + + +bend = IfcPipeFittingTypeEnum.BEND + + +connector = IfcPipeFittingTypeEnum.CONNECTOR + + +entry = IfcPipeFittingTypeEnum.ENTRY + + +exit = IfcPipeFittingTypeEnum.EXIT + + +junction = IfcPipeFittingTypeEnum.JUNCTION + + +obstruction = IfcPipeFittingTypeEnum.OBSTRUCTION + + +transition = IfcPipeFittingTypeEnum.TRANSITION + + +userdefined = IfcPipeFittingTypeEnum.USERDEFINED + + +notdefined = IfcPipeFittingTypeEnum.NOTDEFINED + + +IfcPipeSegmentTypeEnum = enum_namespace() + + +culvert = IfcPipeSegmentTypeEnum.CULVERT + + +flexiblesegment = IfcPipeSegmentTypeEnum.FLEXIBLESEGMENT + + +rigidsegment = IfcPipeSegmentTypeEnum.RIGIDSEGMENT + + +gutter = IfcPipeSegmentTypeEnum.GUTTER + + +spool = IfcPipeSegmentTypeEnum.SPOOL + + +userdefined = IfcPipeSegmentTypeEnum.USERDEFINED + + +notdefined = IfcPipeSegmentTypeEnum.NOTDEFINED + + +IfcPlateTypeEnum = enum_namespace() + + +curtain_panel = IfcPlateTypeEnum.CURTAIN_PANEL + + +sheet = IfcPlateTypeEnum.SHEET + + +flange_plate = IfcPlateTypeEnum.FLANGE_PLATE + + +web_plate = IfcPlateTypeEnum.WEB_PLATE + + +stiffener_plate = IfcPlateTypeEnum.STIFFENER_PLATE + + +gusset_plate = IfcPlateTypeEnum.GUSSET_PLATE + + +cover_plate = IfcPlateTypeEnum.COVER_PLATE + + +splice_plate = IfcPlateTypeEnum.SPLICE_PLATE + + +base_plate = IfcPlateTypeEnum.BASE_PLATE + + +userdefined = IfcPlateTypeEnum.USERDEFINED + + +notdefined = IfcPlateTypeEnum.NOTDEFINED + + +IfcPreferredSurfaceCurveRepresentation = enum_namespace() + + +curve3d = IfcPreferredSurfaceCurveRepresentation.CURVE3D + + +pcurve_s1 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S1 + + +pcurve_s2 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S2 + + +IfcProcedureTypeEnum = enum_namespace() + + +advice_caution = IfcProcedureTypeEnum.ADVICE_CAUTION + + +advice_note = IfcProcedureTypeEnum.ADVICE_NOTE + + +advice_warning = IfcProcedureTypeEnum.ADVICE_WARNING + + +calibration = IfcProcedureTypeEnum.CALIBRATION + + +diagnostic = IfcProcedureTypeEnum.DIAGNOSTIC + + +shutdown = IfcProcedureTypeEnum.SHUTDOWN + + +startup = IfcProcedureTypeEnum.STARTUP + + +userdefined = IfcProcedureTypeEnum.USERDEFINED + + +notdefined = IfcProcedureTypeEnum.NOTDEFINED + + +IfcProfileTypeEnum = enum_namespace() + + +curve = IfcProfileTypeEnum.CURVE + + +area = IfcProfileTypeEnum.AREA + + +IfcProjectOrderTypeEnum = enum_namespace() + + +changeorder = IfcProjectOrderTypeEnum.CHANGEORDER + + +maintenanceworkorder = IfcProjectOrderTypeEnum.MAINTENANCEWORKORDER + + +moveorder = IfcProjectOrderTypeEnum.MOVEORDER + + +purchaseorder = IfcProjectOrderTypeEnum.PURCHASEORDER + + +workorder = IfcProjectOrderTypeEnum.WORKORDER + + +userdefined = IfcProjectOrderTypeEnum.USERDEFINED + + +notdefined = IfcProjectOrderTypeEnum.NOTDEFINED + + +IfcProjectedOrTrueLengthEnum = enum_namespace() + + +projected_length = IfcProjectedOrTrueLengthEnum.PROJECTED_LENGTH + + +true_length = IfcProjectedOrTrueLengthEnum.TRUE_LENGTH + + +IfcProjectionElementTypeEnum = enum_namespace() + + +blister = IfcProjectionElementTypeEnum.BLISTER + + +deviator = IfcProjectionElementTypeEnum.DEVIATOR + + +userdefined = IfcProjectionElementTypeEnum.USERDEFINED + + +notdefined = IfcProjectionElementTypeEnum.NOTDEFINED + + +IfcPropertySetTemplateTypeEnum = enum_namespace() + + +pset_typedrivenonly = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENONLY + + +pset_typedrivenoverride = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENOVERRIDE + + +pset_occurrencedriven = IfcPropertySetTemplateTypeEnum.PSET_OCCURRENCEDRIVEN + + +pset_performancedriven = IfcPropertySetTemplateTypeEnum.PSET_PERFORMANCEDRIVEN + + +qto_typedrivenonly = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENONLY + + +qto_typedrivenoverride = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENOVERRIDE + + +qto_occurrencedriven = IfcPropertySetTemplateTypeEnum.QTO_OCCURRENCEDRIVEN + + +notdefined = IfcPropertySetTemplateTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTrippingUnitTypeEnum = enum_namespace() + + +electronic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTRONIC + + +electromagnetic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTROMAGNETIC + + +residualcurrent = IfcProtectiveDeviceTrippingUnitTypeEnum.RESIDUALCURRENT + + +thermal = IfcProtectiveDeviceTrippingUnitTypeEnum.THERMAL + + +userdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTypeEnum = enum_namespace() + + +circuitbreaker = IfcProtectiveDeviceTypeEnum.CIRCUITBREAKER + + +earthleakagecircuitbreaker = IfcProtectiveDeviceTypeEnum.EARTHLEAKAGECIRCUITBREAKER + + +earthingswitch = IfcProtectiveDeviceTypeEnum.EARTHINGSWITCH + + +fusedisconnector = IfcProtectiveDeviceTypeEnum.FUSEDISCONNECTOR + + +residualcurrentcircuitbreaker = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTCIRCUITBREAKER + + +residualcurrentswitch = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTSWITCH + + +varistor = IfcProtectiveDeviceTypeEnum.VARISTOR + + +anti_arcing_device = IfcProtectiveDeviceTypeEnum.ANTI_ARCING_DEVICE + + +sparkgap = IfcProtectiveDeviceTypeEnum.SPARKGAP + + +voltagelimiter = IfcProtectiveDeviceTypeEnum.VOLTAGELIMITER + + +userdefined = IfcProtectiveDeviceTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTypeEnum.NOTDEFINED + + +IfcPumpTypeEnum = enum_namespace() + + +circulator = IfcPumpTypeEnum.CIRCULATOR + + +endsuction = IfcPumpTypeEnum.ENDSUCTION + + +splitcase = IfcPumpTypeEnum.SPLITCASE + + +submersiblepump = IfcPumpTypeEnum.SUBMERSIBLEPUMP + + +sumppump = IfcPumpTypeEnum.SUMPPUMP + + +verticalinline = IfcPumpTypeEnum.VERTICALINLINE + + +verticalturbine = IfcPumpTypeEnum.VERTICALTURBINE + + +userdefined = IfcPumpTypeEnum.USERDEFINED + + +notdefined = IfcPumpTypeEnum.NOTDEFINED + + +IfcRailTypeEnum = enum_namespace() + + +rackrail = IfcRailTypeEnum.RACKRAIL + + +blade = IfcRailTypeEnum.BLADE + + +guardrail = IfcRailTypeEnum.GUARDRAIL + + +stockrail = IfcRailTypeEnum.STOCKRAIL + + +checkrail = IfcRailTypeEnum.CHECKRAIL + + +rail = IfcRailTypeEnum.RAIL + + +userdefined = IfcRailTypeEnum.USERDEFINED + + +notdefined = IfcRailTypeEnum.NOTDEFINED + + +IfcRailingTypeEnum = enum_namespace() + + +handrail = IfcRailingTypeEnum.HANDRAIL + + +guardrail = IfcRailingTypeEnum.GUARDRAIL + + +balustrade = IfcRailingTypeEnum.BALUSTRADE + + +fence = IfcRailingTypeEnum.FENCE + + +userdefined = IfcRailingTypeEnum.USERDEFINED + + +notdefined = IfcRailingTypeEnum.NOTDEFINED + + +IfcRailwayPartTypeEnum = enum_namespace() + + +trackstructure = IfcRailwayPartTypeEnum.TRACKSTRUCTURE + + +trackstructurepart = IfcRailwayPartTypeEnum.TRACKSTRUCTUREPART + + +linesidestructurepart = IfcRailwayPartTypeEnum.LINESIDESTRUCTUREPART + + +dilatationsuperstructure = IfcRailwayPartTypeEnum.DILATATIONSUPERSTRUCTURE + + +plaintracksupestructure = IfcRailwayPartTypeEnum.PLAINTRACKSUPESTRUCTURE + + +linesidestructure = IfcRailwayPartTypeEnum.LINESIDESTRUCTURE + + +superstructure = IfcRailwayPartTypeEnum.SUPERSTRUCTURE + + +turnoutsuperstructure = IfcRailwayPartTypeEnum.TURNOUTSUPERSTRUCTURE + + +userdefined = IfcRailwayPartTypeEnum.USERDEFINED + + +notdefined = IfcRailwayPartTypeEnum.NOTDEFINED + + +IfcRailwayTypeEnum = enum_namespace() + + +userdefined = IfcRailwayTypeEnum.USERDEFINED + + +notdefined = IfcRailwayTypeEnum.NOTDEFINED + + +IfcRampFlightTypeEnum = enum_namespace() + + +straight = IfcRampFlightTypeEnum.STRAIGHT + + +spiral = IfcRampFlightTypeEnum.SPIRAL + + +userdefined = IfcRampFlightTypeEnum.USERDEFINED + + +notdefined = IfcRampFlightTypeEnum.NOTDEFINED + + +IfcRampTypeEnum = enum_namespace() + + +straight_run_ramp = IfcRampTypeEnum.STRAIGHT_RUN_RAMP + + +two_straight_run_ramp = IfcRampTypeEnum.TWO_STRAIGHT_RUN_RAMP + + +quarter_turn_ramp = IfcRampTypeEnum.QUARTER_TURN_RAMP + + +two_quarter_turn_ramp = IfcRampTypeEnum.TWO_QUARTER_TURN_RAMP + + +half_turn_ramp = IfcRampTypeEnum.HALF_TURN_RAMP + + +spiral_ramp = IfcRampTypeEnum.SPIRAL_RAMP + + +userdefined = IfcRampTypeEnum.USERDEFINED + + +notdefined = IfcRampTypeEnum.NOTDEFINED + + +IfcRecurrenceTypeEnum = enum_namespace() + + +daily = IfcRecurrenceTypeEnum.DAILY + + +weekly = IfcRecurrenceTypeEnum.WEEKLY + + +monthly_by_day_of_month = IfcRecurrenceTypeEnum.MONTHLY_BY_DAY_OF_MONTH + + +monthly_by_position = IfcRecurrenceTypeEnum.MONTHLY_BY_POSITION + + +by_day_count = IfcRecurrenceTypeEnum.BY_DAY_COUNT + + +by_weekday_count = IfcRecurrenceTypeEnum.BY_WEEKDAY_COUNT + + +yearly_by_day_of_month = IfcRecurrenceTypeEnum.YEARLY_BY_DAY_OF_MONTH + + +yearly_by_position = IfcRecurrenceTypeEnum.YEARLY_BY_POSITION + + +IfcReferentTypeEnum = enum_namespace() + + +kilopoint = IfcReferentTypeEnum.KILOPOINT + + +milepoint = IfcReferentTypeEnum.MILEPOINT + + +station = IfcReferentTypeEnum.STATION + + +referencemarker = IfcReferentTypeEnum.REFERENCEMARKER + + +landmark = IfcReferentTypeEnum.LANDMARK + + +boundary = IfcReferentTypeEnum.BOUNDARY + + +intersection = IfcReferentTypeEnum.INTERSECTION + + +position = IfcReferentTypeEnum.POSITION + + +userdefined = IfcReferentTypeEnum.USERDEFINED + + +notdefined = IfcReferentTypeEnum.NOTDEFINED + + +IfcReflectanceMethodEnum = enum_namespace() + + +blinn = IfcReflectanceMethodEnum.BLINN + + +flat = IfcReflectanceMethodEnum.FLAT + + +glass = IfcReflectanceMethodEnum.GLASS + + +matt = IfcReflectanceMethodEnum.MATT + + +metal = IfcReflectanceMethodEnum.METAL + + +mirror = IfcReflectanceMethodEnum.MIRROR + + +phong = IfcReflectanceMethodEnum.PHONG + + +plastic = IfcReflectanceMethodEnum.PLASTIC + + +strauss = IfcReflectanceMethodEnum.STRAUSS + + +notdefined = IfcReflectanceMethodEnum.NOTDEFINED + + +IfcReinforcedSoilTypeEnum = enum_namespace() + + +surchargepreloaded = IfcReinforcedSoilTypeEnum.SURCHARGEPRELOADED + + +verticallydrained = IfcReinforcedSoilTypeEnum.VERTICALLYDRAINED + + +dynamicallycompacted = IfcReinforcedSoilTypeEnum.DYNAMICALLYCOMPACTED + + +replaced = IfcReinforcedSoilTypeEnum.REPLACED + + +rollercompacted = IfcReinforcedSoilTypeEnum.ROLLERCOMPACTED + + +grouted = IfcReinforcedSoilTypeEnum.GROUTED + + +userdefined = IfcReinforcedSoilTypeEnum.USERDEFINED + + +notdefined = IfcReinforcedSoilTypeEnum.NOTDEFINED + + +IfcReinforcingBarRoleEnum = enum_namespace() + + +main = IfcReinforcingBarRoleEnum.MAIN + + +shear = IfcReinforcingBarRoleEnum.SHEAR + + +ligature = IfcReinforcingBarRoleEnum.LIGATURE + + +stud = IfcReinforcingBarRoleEnum.STUD + + +punching = IfcReinforcingBarRoleEnum.PUNCHING + + +edge = IfcReinforcingBarRoleEnum.EDGE + + +ring = IfcReinforcingBarRoleEnum.RING + + +anchoring = IfcReinforcingBarRoleEnum.ANCHORING + + +userdefined = IfcReinforcingBarRoleEnum.USERDEFINED + + +notdefined = IfcReinforcingBarRoleEnum.NOTDEFINED + + +IfcReinforcingBarSurfaceEnum = enum_namespace() + + +plain = IfcReinforcingBarSurfaceEnum.PLAIN + + +textured = IfcReinforcingBarSurfaceEnum.TEXTURED + + +IfcReinforcingBarTypeEnum = enum_namespace() + + +anchoring = IfcReinforcingBarTypeEnum.ANCHORING + + +edge = IfcReinforcingBarTypeEnum.EDGE + + +ligature = IfcReinforcingBarTypeEnum.LIGATURE + + +main = IfcReinforcingBarTypeEnum.MAIN + + +punching = IfcReinforcingBarTypeEnum.PUNCHING + + +ring = IfcReinforcingBarTypeEnum.RING + + +shear = IfcReinforcingBarTypeEnum.SHEAR + + +stud = IfcReinforcingBarTypeEnum.STUD + + +spacebar = IfcReinforcingBarTypeEnum.SPACEBAR + + +userdefined = IfcReinforcingBarTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingBarTypeEnum.NOTDEFINED + + +IfcReinforcingMeshTypeEnum = enum_namespace() + + +userdefined = IfcReinforcingMeshTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingMeshTypeEnum.NOTDEFINED + + +IfcRoadPartTypeEnum = enum_namespace() + + +roadsidepart = IfcRoadPartTypeEnum.ROADSIDEPART + + +bus_stop = IfcRoadPartTypeEnum.BUS_STOP + + +hardshoulder = IfcRoadPartTypeEnum.HARDSHOULDER + + +intersection = IfcRoadPartTypeEnum.INTERSECTION + + +passingbay = IfcRoadPartTypeEnum.PASSINGBAY + + +roadwayplateau = IfcRoadPartTypeEnum.ROADWAYPLATEAU + + +roadside = IfcRoadPartTypeEnum.ROADSIDE + + +refugeisland = IfcRoadPartTypeEnum.REFUGEISLAND + + +tollplaza = IfcRoadPartTypeEnum.TOLLPLAZA + + +centralreserve = IfcRoadPartTypeEnum.CENTRALRESERVE + + +sidewalk = IfcRoadPartTypeEnum.SIDEWALK + + +parkingbay = IfcRoadPartTypeEnum.PARKINGBAY + + +railwaycrossing = IfcRoadPartTypeEnum.RAILWAYCROSSING + + +pedestrian_crossing = IfcRoadPartTypeEnum.PEDESTRIAN_CROSSING + + +softshoulder = IfcRoadPartTypeEnum.SOFTSHOULDER + + +bicyclecrossing = IfcRoadPartTypeEnum.BICYCLECROSSING + + +centralisland = IfcRoadPartTypeEnum.CENTRALISLAND + + +shoulder = IfcRoadPartTypeEnum.SHOULDER + + +trafficlane = IfcRoadPartTypeEnum.TRAFFICLANE + + +roadsegment = IfcRoadPartTypeEnum.ROADSEGMENT + + +roundabout = IfcRoadPartTypeEnum.ROUNDABOUT + + +layby = IfcRoadPartTypeEnum.LAYBY + + +carriageway = IfcRoadPartTypeEnum.CARRIAGEWAY + + +trafficisland = IfcRoadPartTypeEnum.TRAFFICISLAND + + +userdefined = IfcRoadPartTypeEnum.USERDEFINED + + +notdefined = IfcRoadPartTypeEnum.NOTDEFINED + + +IfcRoadTypeEnum = enum_namespace() + + +userdefined = IfcRoadTypeEnum.USERDEFINED + + +notdefined = IfcRoadTypeEnum.NOTDEFINED + + +IfcRoleEnum = enum_namespace() + + +supplier = IfcRoleEnum.SUPPLIER + + +manufacturer = IfcRoleEnum.MANUFACTURER + + +contractor = IfcRoleEnum.CONTRACTOR + + +subcontractor = IfcRoleEnum.SUBCONTRACTOR + + +architect = IfcRoleEnum.ARCHITECT + + +structuralengineer = IfcRoleEnum.STRUCTURALENGINEER + + +costengineer = IfcRoleEnum.COSTENGINEER + + +client = IfcRoleEnum.CLIENT + + +buildingowner = IfcRoleEnum.BUILDINGOWNER + + +buildingoperator = IfcRoleEnum.BUILDINGOPERATOR + + +mechanicalengineer = IfcRoleEnum.MECHANICALENGINEER + + +electricalengineer = IfcRoleEnum.ELECTRICALENGINEER + + +projectmanager = IfcRoleEnum.PROJECTMANAGER + + +facilitiesmanager = IfcRoleEnum.FACILITIESMANAGER + + +civilengineer = IfcRoleEnum.CIVILENGINEER + + +commissioningengineer = IfcRoleEnum.COMMISSIONINGENGINEER + + +engineer = IfcRoleEnum.ENGINEER + + +owner = IfcRoleEnum.OWNER + + +consultant = IfcRoleEnum.CONSULTANT + + +constructionmanager = IfcRoleEnum.CONSTRUCTIONMANAGER + + +fieldconstructionmanager = IfcRoleEnum.FIELDCONSTRUCTIONMANAGER + + +reseller = IfcRoleEnum.RESELLER + + +userdefined = IfcRoleEnum.USERDEFINED + + +IfcRoofTypeEnum = enum_namespace() + + +flat_roof = IfcRoofTypeEnum.FLAT_ROOF + + +shed_roof = IfcRoofTypeEnum.SHED_ROOF + + +gable_roof = IfcRoofTypeEnum.GABLE_ROOF + + +hip_roof = IfcRoofTypeEnum.HIP_ROOF + + +hipped_gable_roof = IfcRoofTypeEnum.HIPPED_GABLE_ROOF + + +gambrel_roof = IfcRoofTypeEnum.GAMBREL_ROOF + + +mansard_roof = IfcRoofTypeEnum.MANSARD_ROOF + + +barrel_roof = IfcRoofTypeEnum.BARREL_ROOF + + +rainbow_roof = IfcRoofTypeEnum.RAINBOW_ROOF + + +butterfly_roof = IfcRoofTypeEnum.BUTTERFLY_ROOF + + +pavilion_roof = IfcRoofTypeEnum.PAVILION_ROOF + + +dome_roof = IfcRoofTypeEnum.DOME_ROOF + + +freeform = IfcRoofTypeEnum.FREEFORM + + +userdefined = IfcRoofTypeEnum.USERDEFINED + + +notdefined = IfcRoofTypeEnum.NOTDEFINED + + +IfcSIPrefix = enum_namespace() + + +exa = IfcSIPrefix.EXA + + +peta = IfcSIPrefix.PETA + + +tera = IfcSIPrefix.TERA + + +giga = IfcSIPrefix.GIGA + + +mega = IfcSIPrefix.MEGA + + +kilo = IfcSIPrefix.KILO + + +hecto = IfcSIPrefix.HECTO + + +deca = IfcSIPrefix.DECA + + +deci = IfcSIPrefix.DECI + + +centi = IfcSIPrefix.CENTI + + +milli = IfcSIPrefix.MILLI + + +micro = IfcSIPrefix.MICRO + + +nano = IfcSIPrefix.NANO + + +pico = IfcSIPrefix.PICO + + +femto = IfcSIPrefix.FEMTO + + +atto = IfcSIPrefix.ATTO + + +IfcSIUnitName = enum_namespace() + + +ampere = IfcSIUnitName.AMPERE + + +becquerel = IfcSIUnitName.BECQUEREL + + +candela = IfcSIUnitName.CANDELA + + +coulomb = IfcSIUnitName.COULOMB + + +cubic_metre = IfcSIUnitName.CUBIC_METRE + + +degree_celsius = IfcSIUnitName.DEGREE_CELSIUS + + +farad = IfcSIUnitName.FARAD + + +gram = IfcSIUnitName.GRAM + + +gray = IfcSIUnitName.GRAY + + +henry = IfcSIUnitName.HENRY + + +hertz = IfcSIUnitName.HERTZ + + +joule = IfcSIUnitName.JOULE + + +kelvin = IfcSIUnitName.KELVIN + + +lumen = IfcSIUnitName.LUMEN + + +lux = IfcSIUnitName.LUX + + +metre = IfcSIUnitName.METRE + + +mole = IfcSIUnitName.MOLE + + +newton = IfcSIUnitName.NEWTON + + +ohm = IfcSIUnitName.OHM + + +pascal = IfcSIUnitName.PASCAL + + +radian = IfcSIUnitName.RADIAN + + +second = IfcSIUnitName.SECOND + + +siemens = IfcSIUnitName.SIEMENS + + +sievert = IfcSIUnitName.SIEVERT + + +square_metre = IfcSIUnitName.SQUARE_METRE + + +steradian = IfcSIUnitName.STERADIAN + + +tesla = IfcSIUnitName.TESLA + + +volt = IfcSIUnitName.VOLT + + +watt = IfcSIUnitName.WATT + + +weber = IfcSIUnitName.WEBER + + +IfcSanitaryTerminalTypeEnum = enum_namespace() + + +bath = IfcSanitaryTerminalTypeEnum.BATH + + +bidet = IfcSanitaryTerminalTypeEnum.BIDET + + +cistern = IfcSanitaryTerminalTypeEnum.CISTERN + + +shower = IfcSanitaryTerminalTypeEnum.SHOWER + + +sink = IfcSanitaryTerminalTypeEnum.SINK + + +sanitaryfountain = IfcSanitaryTerminalTypeEnum.SANITARYFOUNTAIN + + +toiletpan = IfcSanitaryTerminalTypeEnum.TOILETPAN + + +urinal = IfcSanitaryTerminalTypeEnum.URINAL + + +washhandbasin = IfcSanitaryTerminalTypeEnum.WASHHANDBASIN + + +wcseat = IfcSanitaryTerminalTypeEnum.WCSEAT + + +userdefined = IfcSanitaryTerminalTypeEnum.USERDEFINED + + +notdefined = IfcSanitaryTerminalTypeEnum.NOTDEFINED + + +IfcSectionTypeEnum = enum_namespace() + + +uniform = IfcSectionTypeEnum.UNIFORM + + +tapered = IfcSectionTypeEnum.TAPERED + + +IfcSensorTypeEnum = enum_namespace() + + +cosensor = IfcSensorTypeEnum.COSENSOR + + +co2sensor = IfcSensorTypeEnum.CO2SENSOR + + +conductancesensor = IfcSensorTypeEnum.CONDUCTANCESENSOR + + +contactsensor = IfcSensorTypeEnum.CONTACTSENSOR + + +firesensor = IfcSensorTypeEnum.FIRESENSOR + + +flowsensor = IfcSensorTypeEnum.FLOWSENSOR + + +frostsensor = IfcSensorTypeEnum.FROSTSENSOR + + +gassensor = IfcSensorTypeEnum.GASSENSOR + + +heatsensor = IfcSensorTypeEnum.HEATSENSOR + + +humiditysensor = IfcSensorTypeEnum.HUMIDITYSENSOR + + +identifiersensor = IfcSensorTypeEnum.IDENTIFIERSENSOR + + +ionconcentrationsensor = IfcSensorTypeEnum.IONCONCENTRATIONSENSOR + + +levelsensor = IfcSensorTypeEnum.LEVELSENSOR + + +lightsensor = IfcSensorTypeEnum.LIGHTSENSOR + + +moisturesensor = IfcSensorTypeEnum.MOISTURESENSOR + + +movementsensor = IfcSensorTypeEnum.MOVEMENTSENSOR + + +phsensor = IfcSensorTypeEnum.PHSENSOR + + +pressuresensor = IfcSensorTypeEnum.PRESSURESENSOR + + +radiationsensor = IfcSensorTypeEnum.RADIATIONSENSOR + + +radioactivitysensor = IfcSensorTypeEnum.RADIOACTIVITYSENSOR + + +smokesensor = IfcSensorTypeEnum.SMOKESENSOR + + +soundsensor = IfcSensorTypeEnum.SOUNDSENSOR + + +temperaturesensor = IfcSensorTypeEnum.TEMPERATURESENSOR + + +windsensor = IfcSensorTypeEnum.WINDSENSOR + + +earthquakesensor = IfcSensorTypeEnum.EARTHQUAKESENSOR + + +foreignobjectdetectionsensor = IfcSensorTypeEnum.FOREIGNOBJECTDETECTIONSENSOR + + +obstaclesensor = IfcSensorTypeEnum.OBSTACLESENSOR + + +rainsensor = IfcSensorTypeEnum.RAINSENSOR + + +snowdepthsensor = IfcSensorTypeEnum.SNOWDEPTHSENSOR + + +trainsensor = IfcSensorTypeEnum.TRAINSENSOR + + +turnoutclosuresensor = IfcSensorTypeEnum.TURNOUTCLOSURESENSOR + + +wheelsensor = IfcSensorTypeEnum.WHEELSENSOR + + +userdefined = IfcSensorTypeEnum.USERDEFINED + + +notdefined = IfcSensorTypeEnum.NOTDEFINED + + +IfcSequenceEnum = enum_namespace() + + +start_start = IfcSequenceEnum.START_START + + +start_finish = IfcSequenceEnum.START_FINISH + + +finish_start = IfcSequenceEnum.FINISH_START + + +finish_finish = IfcSequenceEnum.FINISH_FINISH + + +userdefined = IfcSequenceEnum.USERDEFINED + + +notdefined = IfcSequenceEnum.NOTDEFINED + + +IfcShadingDeviceTypeEnum = enum_namespace() + + +jalousie = IfcShadingDeviceTypeEnum.JALOUSIE + + +shutter = IfcShadingDeviceTypeEnum.SHUTTER + + +awning = IfcShadingDeviceTypeEnum.AWNING + + +userdefined = IfcShadingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcShadingDeviceTypeEnum.NOTDEFINED + + +IfcSignTypeEnum = enum_namespace() + + +marker = IfcSignTypeEnum.MARKER + + +pictoral = IfcSignTypeEnum.PICTORAL + + +mirror = IfcSignTypeEnum.MIRROR + + +userdefined = IfcSignTypeEnum.USERDEFINED + + +notdefined = IfcSignTypeEnum.NOTDEFINED + + +IfcSignalTypeEnum = enum_namespace() + + +visual = IfcSignalTypeEnum.VISUAL + + +audio = IfcSignalTypeEnum.AUDIO + + +mixed = IfcSignalTypeEnum.MIXED + + +userdefined = IfcSignalTypeEnum.USERDEFINED + + +notdefined = IfcSignalTypeEnum.NOTDEFINED + + +IfcSimplePropertyTemplateTypeEnum = enum_namespace() + + +p_singlevalue = IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE + + +p_enumeratedvalue = IfcSimplePropertyTemplateTypeEnum.P_ENUMERATEDVALUE + + +p_boundedvalue = IfcSimplePropertyTemplateTypeEnum.P_BOUNDEDVALUE + + +p_listvalue = IfcSimplePropertyTemplateTypeEnum.P_LISTVALUE + + +p_tablevalue = IfcSimplePropertyTemplateTypeEnum.P_TABLEVALUE + + +p_referencevalue = IfcSimplePropertyTemplateTypeEnum.P_REFERENCEVALUE + + +q_length = IfcSimplePropertyTemplateTypeEnum.Q_LENGTH + + +q_area = IfcSimplePropertyTemplateTypeEnum.Q_AREA + + +q_volume = IfcSimplePropertyTemplateTypeEnum.Q_VOLUME + + +q_count = IfcSimplePropertyTemplateTypeEnum.Q_COUNT + + +q_weight = IfcSimplePropertyTemplateTypeEnum.Q_WEIGHT + + +q_time = IfcSimplePropertyTemplateTypeEnum.Q_TIME + + +IfcSlabTypeEnum = enum_namespace() + + +floor = IfcSlabTypeEnum.FLOOR + + +roof = IfcSlabTypeEnum.ROOF + + +landing = IfcSlabTypeEnum.LANDING + + +baseslab = IfcSlabTypeEnum.BASESLAB + + +approach_slab = IfcSlabTypeEnum.APPROACH_SLAB + + +paving = IfcSlabTypeEnum.PAVING + + +wearing = IfcSlabTypeEnum.WEARING + + +sidewalk = IfcSlabTypeEnum.SIDEWALK + + +trackslab = IfcSlabTypeEnum.TRACKSLAB + + +userdefined = IfcSlabTypeEnum.USERDEFINED + + +notdefined = IfcSlabTypeEnum.NOTDEFINED + + +IfcSolarDeviceTypeEnum = enum_namespace() + + +solarcollector = IfcSolarDeviceTypeEnum.SOLARCOLLECTOR + + +solarpanel = IfcSolarDeviceTypeEnum.SOLARPANEL + + +userdefined = IfcSolarDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSolarDeviceTypeEnum.NOTDEFINED + + +IfcSpaceHeaterTypeEnum = enum_namespace() + + +convector = IfcSpaceHeaterTypeEnum.CONVECTOR + + +radiator = IfcSpaceHeaterTypeEnum.RADIATOR + + +userdefined = IfcSpaceHeaterTypeEnum.USERDEFINED + + +notdefined = IfcSpaceHeaterTypeEnum.NOTDEFINED + + +IfcSpaceTypeEnum = enum_namespace() + + +space = IfcSpaceTypeEnum.SPACE + + +parking = IfcSpaceTypeEnum.PARKING + + +gfa = IfcSpaceTypeEnum.GFA + + +internal = IfcSpaceTypeEnum.INTERNAL + + +external = IfcSpaceTypeEnum.EXTERNAL + + +berth = IfcSpaceTypeEnum.BERTH + + +userdefined = IfcSpaceTypeEnum.USERDEFINED + + +notdefined = IfcSpaceTypeEnum.NOTDEFINED + + +IfcSpatialZoneTypeEnum = enum_namespace() + + +construction = IfcSpatialZoneTypeEnum.CONSTRUCTION + + +firesafety = IfcSpatialZoneTypeEnum.FIRESAFETY + + +lighting = IfcSpatialZoneTypeEnum.LIGHTING + + +occupancy = IfcSpatialZoneTypeEnum.OCCUPANCY + + +security = IfcSpatialZoneTypeEnum.SECURITY + + +thermal = IfcSpatialZoneTypeEnum.THERMAL + + +transport = IfcSpatialZoneTypeEnum.TRANSPORT + + +ventilation = IfcSpatialZoneTypeEnum.VENTILATION + + +reservation = IfcSpatialZoneTypeEnum.RESERVATION + + +interference = IfcSpatialZoneTypeEnum.INTERFERENCE + + +userdefined = IfcSpatialZoneTypeEnum.USERDEFINED + + +notdefined = IfcSpatialZoneTypeEnum.NOTDEFINED + + +IfcStackTerminalTypeEnum = enum_namespace() + + +birdcage = IfcStackTerminalTypeEnum.BIRDCAGE + + +cowl = IfcStackTerminalTypeEnum.COWL + + +rainwaterhopper = IfcStackTerminalTypeEnum.RAINWATERHOPPER + + +userdefined = IfcStackTerminalTypeEnum.USERDEFINED + + +notdefined = IfcStackTerminalTypeEnum.NOTDEFINED + + +IfcStairFlightTypeEnum = enum_namespace() + + +straight = IfcStairFlightTypeEnum.STRAIGHT + + +winder = IfcStairFlightTypeEnum.WINDER + + +spiral = IfcStairFlightTypeEnum.SPIRAL + + +curved = IfcStairFlightTypeEnum.CURVED + + +freeform = IfcStairFlightTypeEnum.FREEFORM + + +userdefined = IfcStairFlightTypeEnum.USERDEFINED + + +notdefined = IfcStairFlightTypeEnum.NOTDEFINED + + +IfcStairTypeEnum = enum_namespace() + + +straight_run_stair = IfcStairTypeEnum.STRAIGHT_RUN_STAIR + + +two_straight_run_stair = IfcStairTypeEnum.TWO_STRAIGHT_RUN_STAIR + + +quarter_winding_stair = IfcStairTypeEnum.QUARTER_WINDING_STAIR + + +quarter_turn_stair = IfcStairTypeEnum.QUARTER_TURN_STAIR + + +half_winding_stair = IfcStairTypeEnum.HALF_WINDING_STAIR + + +half_turn_stair = IfcStairTypeEnum.HALF_TURN_STAIR + + +two_quarter_winding_stair = IfcStairTypeEnum.TWO_QUARTER_WINDING_STAIR + + +two_quarter_turn_stair = IfcStairTypeEnum.TWO_QUARTER_TURN_STAIR + + +three_quarter_winding_stair = IfcStairTypeEnum.THREE_QUARTER_WINDING_STAIR + + +three_quarter_turn_stair = IfcStairTypeEnum.THREE_QUARTER_TURN_STAIR + + +spiral_stair = IfcStairTypeEnum.SPIRAL_STAIR + + +double_return_stair = IfcStairTypeEnum.DOUBLE_RETURN_STAIR + + +curved_run_stair = IfcStairTypeEnum.CURVED_RUN_STAIR + + +two_curved_run_stair = IfcStairTypeEnum.TWO_CURVED_RUN_STAIR + + +ladder = IfcStairTypeEnum.LADDER + + +userdefined = IfcStairTypeEnum.USERDEFINED + + +notdefined = IfcStairTypeEnum.NOTDEFINED + + +IfcStateEnum = enum_namespace() + + +readwrite = IfcStateEnum.READWRITE + + +readonly = IfcStateEnum.READONLY + + +locked = IfcStateEnum.LOCKED + + +readwritelocked = IfcStateEnum.READWRITELOCKED + + +readonlylocked = IfcStateEnum.READONLYLOCKED + + +IfcStructuralCurveActivityTypeEnum = enum_namespace() + + +const = IfcStructuralCurveActivityTypeEnum.CONST + + +linear = IfcStructuralCurveActivityTypeEnum.LINEAR + + +polygonal = IfcStructuralCurveActivityTypeEnum.POLYGONAL + + +equidistant = IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + +sinus = IfcStructuralCurveActivityTypeEnum.SINUS + + +parabola = IfcStructuralCurveActivityTypeEnum.PARABOLA + + +discrete = IfcStructuralCurveActivityTypeEnum.DISCRETE + + +userdefined = IfcStructuralCurveActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveActivityTypeEnum.NOTDEFINED + + +IfcStructuralCurveMemberTypeEnum = enum_namespace() + + +rigid_joined_member = IfcStructuralCurveMemberTypeEnum.RIGID_JOINED_MEMBER + + +pin_joined_member = IfcStructuralCurveMemberTypeEnum.PIN_JOINED_MEMBER + + +cable = IfcStructuralCurveMemberTypeEnum.CABLE + + +tension_member = IfcStructuralCurveMemberTypeEnum.TENSION_MEMBER + + +compression_member = IfcStructuralCurveMemberTypeEnum.COMPRESSION_MEMBER + + +userdefined = IfcStructuralCurveMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveMemberTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceActivityTypeEnum = enum_namespace() + + +const = IfcStructuralSurfaceActivityTypeEnum.CONST + + +bilinear = IfcStructuralSurfaceActivityTypeEnum.BILINEAR + + +discrete = IfcStructuralSurfaceActivityTypeEnum.DISCRETE + + +isocontour = IfcStructuralSurfaceActivityTypeEnum.ISOCONTOUR + + +userdefined = IfcStructuralSurfaceActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceActivityTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceMemberTypeEnum = enum_namespace() + + +bending_element = IfcStructuralSurfaceMemberTypeEnum.BENDING_ELEMENT + + +membrane_element = IfcStructuralSurfaceMemberTypeEnum.MEMBRANE_ELEMENT + + +shell = IfcStructuralSurfaceMemberTypeEnum.SHELL + + +userdefined = IfcStructuralSurfaceMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceMemberTypeEnum.NOTDEFINED + + +IfcSubContractResourceTypeEnum = enum_namespace() + + +purchase = IfcSubContractResourceTypeEnum.PURCHASE + + +work = IfcSubContractResourceTypeEnum.WORK + + +userdefined = IfcSubContractResourceTypeEnum.USERDEFINED + + +notdefined = IfcSubContractResourceTypeEnum.NOTDEFINED + + +IfcSurfaceFeatureTypeEnum = enum_namespace() + + +mark = IfcSurfaceFeatureTypeEnum.MARK + + +tag = IfcSurfaceFeatureTypeEnum.TAG + + +treatment = IfcSurfaceFeatureTypeEnum.TREATMENT + + +defect = IfcSurfaceFeatureTypeEnum.DEFECT + + +hatchmarking = IfcSurfaceFeatureTypeEnum.HATCHMARKING + + +linemarking = IfcSurfaceFeatureTypeEnum.LINEMARKING + + +pavementsurfacemarking = IfcSurfaceFeatureTypeEnum.PAVEMENTSURFACEMARKING + + +symbolmarking = IfcSurfaceFeatureTypeEnum.SYMBOLMARKING + + +nonskidsurfacing = IfcSurfaceFeatureTypeEnum.NONSKIDSURFACING + + +rumblestrip = IfcSurfaceFeatureTypeEnum.RUMBLESTRIP + + +transverserumblestrip = IfcSurfaceFeatureTypeEnum.TRANSVERSERUMBLESTRIP + + +userdefined = IfcSurfaceFeatureTypeEnum.USERDEFINED + + +notdefined = IfcSurfaceFeatureTypeEnum.NOTDEFINED + + +IfcSurfaceSide = enum_namespace() + + +positive = IfcSurfaceSide.POSITIVE + + +negative = IfcSurfaceSide.NEGATIVE + + +both = IfcSurfaceSide.BOTH + + +IfcSwitchingDeviceTypeEnum = enum_namespace() + + +contactor = IfcSwitchingDeviceTypeEnum.CONTACTOR + + +dimmerswitch = IfcSwitchingDeviceTypeEnum.DIMMERSWITCH + + +emergencystop = IfcSwitchingDeviceTypeEnum.EMERGENCYSTOP + + +keypad = IfcSwitchingDeviceTypeEnum.KEYPAD + + +momentaryswitch = IfcSwitchingDeviceTypeEnum.MOMENTARYSWITCH + + +selectorswitch = IfcSwitchingDeviceTypeEnum.SELECTORSWITCH + + +starter = IfcSwitchingDeviceTypeEnum.STARTER + + +switchdisconnector = IfcSwitchingDeviceTypeEnum.SWITCHDISCONNECTOR + + +toggleswitch = IfcSwitchingDeviceTypeEnum.TOGGLESWITCH + + +relay = IfcSwitchingDeviceTypeEnum.RELAY + + +start_and_stop_equipment = IfcSwitchingDeviceTypeEnum.START_AND_STOP_EQUIPMENT + + +userdefined = IfcSwitchingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSwitchingDeviceTypeEnum.NOTDEFINED + + +IfcSystemFurnitureElementTypeEnum = enum_namespace() + + +panel = IfcSystemFurnitureElementTypeEnum.PANEL + + +worksurface = IfcSystemFurnitureElementTypeEnum.WORKSURFACE + + +subrack = IfcSystemFurnitureElementTypeEnum.SUBRACK + + +userdefined = IfcSystemFurnitureElementTypeEnum.USERDEFINED + + +notdefined = IfcSystemFurnitureElementTypeEnum.NOTDEFINED + + +IfcTankTypeEnum = enum_namespace() + + +basin = IfcTankTypeEnum.BASIN + + +breakpressure = IfcTankTypeEnum.BREAKPRESSURE + + +expansion = IfcTankTypeEnum.EXPANSION + + +feedandexpansion = IfcTankTypeEnum.FEEDANDEXPANSION + + +pressurevessel = IfcTankTypeEnum.PRESSUREVESSEL + + +storage = IfcTankTypeEnum.STORAGE + + +vessel = IfcTankTypeEnum.VESSEL + + +oilretentiontray = IfcTankTypeEnum.OILRETENTIONTRAY + + +userdefined = IfcTankTypeEnum.USERDEFINED + + +notdefined = IfcTankTypeEnum.NOTDEFINED + + +IfcTaskDurationEnum = enum_namespace() + + +elapsedtime = IfcTaskDurationEnum.ELAPSEDTIME + + +worktime = IfcTaskDurationEnum.WORKTIME + + +notdefined = IfcTaskDurationEnum.NOTDEFINED + + +IfcTaskTypeEnum = enum_namespace() + + +attendance = IfcTaskTypeEnum.ATTENDANCE + + +construction = IfcTaskTypeEnum.CONSTRUCTION + + +demolition = IfcTaskTypeEnum.DEMOLITION + + +dismantle = IfcTaskTypeEnum.DISMANTLE + + +disposal = IfcTaskTypeEnum.DISPOSAL + + +installation = IfcTaskTypeEnum.INSTALLATION + + +logistic = IfcTaskTypeEnum.LOGISTIC + + +maintenance = IfcTaskTypeEnum.MAINTENANCE + + +move = IfcTaskTypeEnum.MOVE + + +operation = IfcTaskTypeEnum.OPERATION + + +removal = IfcTaskTypeEnum.REMOVAL + + +renovation = IfcTaskTypeEnum.RENOVATION + + +userdefined = IfcTaskTypeEnum.USERDEFINED + + +notdefined = IfcTaskTypeEnum.NOTDEFINED + + +IfcTendonAnchorTypeEnum = enum_namespace() + + +coupler = IfcTendonAnchorTypeEnum.COUPLER + + +fixed_end = IfcTendonAnchorTypeEnum.FIXED_END + + +tensioning_end = IfcTendonAnchorTypeEnum.TENSIONING_END + + +userdefined = IfcTendonAnchorTypeEnum.USERDEFINED + + +notdefined = IfcTendonAnchorTypeEnum.NOTDEFINED + + +IfcTendonConduitTypeEnum = enum_namespace() + + +duct = IfcTendonConduitTypeEnum.DUCT + + +coupler = IfcTendonConduitTypeEnum.COUPLER + + +grouting_duct = IfcTendonConduitTypeEnum.GROUTING_DUCT + + +trumpet = IfcTendonConduitTypeEnum.TRUMPET + + +diabolo = IfcTendonConduitTypeEnum.DIABOLO + + +userdefined = IfcTendonConduitTypeEnum.USERDEFINED + + +notdefined = IfcTendonConduitTypeEnum.NOTDEFINED + + +IfcTendonTypeEnum = enum_namespace() + + +bar = IfcTendonTypeEnum.BAR + + +coated = IfcTendonTypeEnum.COATED + + +strand = IfcTendonTypeEnum.STRAND + + +wire = IfcTendonTypeEnum.WIRE + + +userdefined = IfcTendonTypeEnum.USERDEFINED + + +notdefined = IfcTendonTypeEnum.NOTDEFINED + + +IfcTextPath = enum_namespace() + + +left = IfcTextPath.LEFT + + +right = IfcTextPath.RIGHT + + +up = IfcTextPath.UP + + +down = IfcTextPath.DOWN + + +IfcTimeSeriesDataTypeEnum = enum_namespace() + + +continuous = IfcTimeSeriesDataTypeEnum.CONTINUOUS + + +discrete = IfcTimeSeriesDataTypeEnum.DISCRETE + + +discretebinary = IfcTimeSeriesDataTypeEnum.DISCRETEBINARY + + +piecewisebinary = IfcTimeSeriesDataTypeEnum.PIECEWISEBINARY + + +piecewiseconstant = IfcTimeSeriesDataTypeEnum.PIECEWISECONSTANT + + +piecewisecontinuous = IfcTimeSeriesDataTypeEnum.PIECEWISECONTINUOUS + + +notdefined = IfcTimeSeriesDataTypeEnum.NOTDEFINED + + +IfcTrackElementTypeEnum = enum_namespace() + + +trackendofalignment = IfcTrackElementTypeEnum.TRACKENDOFALIGNMENT + + +blockingdevice = IfcTrackElementTypeEnum.BLOCKINGDEVICE + + +vehiclestop = IfcTrackElementTypeEnum.VEHICLESTOP + + +sleeper = IfcTrackElementTypeEnum.SLEEPER + + +half_set_of_blades = IfcTrackElementTypeEnum.HALF_SET_OF_BLADES + + +speedregulator = IfcTrackElementTypeEnum.SPEEDREGULATOR + + +derailer = IfcTrackElementTypeEnum.DERAILER + + +frog = IfcTrackElementTypeEnum.FROG + + +userdefined = IfcTrackElementTypeEnum.USERDEFINED + + +notdefined = IfcTrackElementTypeEnum.NOTDEFINED + + +IfcTransformerTypeEnum = enum_namespace() + + +current = IfcTransformerTypeEnum.CURRENT + + +frequency = IfcTransformerTypeEnum.FREQUENCY + + +inverter = IfcTransformerTypeEnum.INVERTER + + +rectifier = IfcTransformerTypeEnum.RECTIFIER + + +voltage = IfcTransformerTypeEnum.VOLTAGE + + +chopper = IfcTransformerTypeEnum.CHOPPER + + +combined = IfcTransformerTypeEnum.COMBINED + + +userdefined = IfcTransformerTypeEnum.USERDEFINED + + +notdefined = IfcTransformerTypeEnum.NOTDEFINED + + +IfcTransitionCode = enum_namespace() + + +discontinuous = IfcTransitionCode.DISCONTINUOUS + + +continuous = IfcTransitionCode.CONTINUOUS + + +contsamegradient = IfcTransitionCode.CONTSAMEGRADIENT + + +contsamegradientsamecurvature = IfcTransitionCode.CONTSAMEGRADIENTSAMECURVATURE + + +IfcTransportElementFixedTypeEnum = enum_namespace() + + +elevator = IfcTransportElementFixedTypeEnum.ELEVATOR + + +escalator = IfcTransportElementFixedTypeEnum.ESCALATOR + + +movingwalkway = IfcTransportElementFixedTypeEnum.MOVINGWALKWAY + + +craneway = IfcTransportElementFixedTypeEnum.CRANEWAY + + +liftinggear = IfcTransportElementFixedTypeEnum.LIFTINGGEAR + + +haulinggear = IfcTransportElementFixedTypeEnum.HAULINGGEAR + + +userdefined = IfcTransportElementFixedTypeEnum.USERDEFINED + + +notdefined = IfcTransportElementFixedTypeEnum.NOTDEFINED + + +IfcTransportElementNonFixedTypeEnum = enum_namespace() + + +vehicle = IfcTransportElementNonFixedTypeEnum.VEHICLE + + +vehicletracked = IfcTransportElementNonFixedTypeEnum.VEHICLETRACKED + + +rollingstock = IfcTransportElementNonFixedTypeEnum.ROLLINGSTOCK + + +vehiclewheeled = IfcTransportElementNonFixedTypeEnum.VEHICLEWHEELED + + +vehicleair = IfcTransportElementNonFixedTypeEnum.VEHICLEAIR + + +cargo = IfcTransportElementNonFixedTypeEnum.CARGO + + +vehiclemarine = IfcTransportElementNonFixedTypeEnum.VEHICLEMARINE + + +userdefined = IfcTransportElementNonFixedTypeEnum.USERDEFINED + + +notdefined = IfcTransportElementNonFixedTypeEnum.NOTDEFINED + + +IfcTrimmingPreference = enum_namespace() + + +cartesian = IfcTrimmingPreference.CARTESIAN + + +parameter = IfcTrimmingPreference.PARAMETER + + +unspecified = IfcTrimmingPreference.UNSPECIFIED + + +IfcTubeBundleTypeEnum = enum_namespace() + + +finned = IfcTubeBundleTypeEnum.FINNED + + +userdefined = IfcTubeBundleTypeEnum.USERDEFINED + + +notdefined = IfcTubeBundleTypeEnum.NOTDEFINED + + +IfcUnitEnum = enum_namespace() + + +absorbeddoseunit = IfcUnitEnum.ABSORBEDDOSEUNIT + + +amountofsubstanceunit = IfcUnitEnum.AMOUNTOFSUBSTANCEUNIT + + +areaunit = IfcUnitEnum.AREAUNIT + + +doseequivalentunit = IfcUnitEnum.DOSEEQUIVALENTUNIT + + +electriccapacitanceunit = IfcUnitEnum.ELECTRICCAPACITANCEUNIT + + +electricchargeunit = IfcUnitEnum.ELECTRICCHARGEUNIT + + +electricconductanceunit = IfcUnitEnum.ELECTRICCONDUCTANCEUNIT + + +electriccurrentunit = IfcUnitEnum.ELECTRICCURRENTUNIT + + +electricresistanceunit = IfcUnitEnum.ELECTRICRESISTANCEUNIT + + +electricvoltageunit = IfcUnitEnum.ELECTRICVOLTAGEUNIT + + +energyunit = IfcUnitEnum.ENERGYUNIT + + +forceunit = IfcUnitEnum.FORCEUNIT + + +frequencyunit = IfcUnitEnum.FREQUENCYUNIT + + +illuminanceunit = IfcUnitEnum.ILLUMINANCEUNIT + + +inductanceunit = IfcUnitEnum.INDUCTANCEUNIT + + +lengthunit = IfcUnitEnum.LENGTHUNIT + + +luminousfluxunit = IfcUnitEnum.LUMINOUSFLUXUNIT + + +luminousintensityunit = IfcUnitEnum.LUMINOUSINTENSITYUNIT + + +magneticfluxdensityunit = IfcUnitEnum.MAGNETICFLUXDENSITYUNIT + + +magneticfluxunit = IfcUnitEnum.MAGNETICFLUXUNIT + + +massunit = IfcUnitEnum.MASSUNIT + + +planeangleunit = IfcUnitEnum.PLANEANGLEUNIT + + +powerunit = IfcUnitEnum.POWERUNIT + + +pressureunit = IfcUnitEnum.PRESSUREUNIT + + +radioactivityunit = IfcUnitEnum.RADIOACTIVITYUNIT + + +solidangleunit = IfcUnitEnum.SOLIDANGLEUNIT + + +thermodynamictemperatureunit = IfcUnitEnum.THERMODYNAMICTEMPERATUREUNIT + + +timeunit = IfcUnitEnum.TIMEUNIT + + +volumeunit = IfcUnitEnum.VOLUMEUNIT + + +userdefined = IfcUnitEnum.USERDEFINED + + +IfcUnitaryControlElementTypeEnum = enum_namespace() + + +alarmpanel = IfcUnitaryControlElementTypeEnum.ALARMPANEL + + +controlpanel = IfcUnitaryControlElementTypeEnum.CONTROLPANEL + + +gasdetectionpanel = IfcUnitaryControlElementTypeEnum.GASDETECTIONPANEL + + +indicatorpanel = IfcUnitaryControlElementTypeEnum.INDICATORPANEL + + +mimicpanel = IfcUnitaryControlElementTypeEnum.MIMICPANEL + + +humidistat = IfcUnitaryControlElementTypeEnum.HUMIDISTAT + + +thermostat = IfcUnitaryControlElementTypeEnum.THERMOSTAT + + +weatherstation = IfcUnitaryControlElementTypeEnum.WEATHERSTATION + + +combined = IfcUnitaryControlElementTypeEnum.COMBINED + + +basestationcontroller = IfcUnitaryControlElementTypeEnum.BASESTATIONCONTROLLER + + +userdefined = IfcUnitaryControlElementTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryControlElementTypeEnum.NOTDEFINED + + +IfcUnitaryEquipmentTypeEnum = enum_namespace() + + +airhandler = IfcUnitaryEquipmentTypeEnum.AIRHANDLER + + +airconditioningunit = IfcUnitaryEquipmentTypeEnum.AIRCONDITIONINGUNIT + + +dehumidifier = IfcUnitaryEquipmentTypeEnum.DEHUMIDIFIER + + +splitsystem = IfcUnitaryEquipmentTypeEnum.SPLITSYSTEM + + +rooftopunit = IfcUnitaryEquipmentTypeEnum.ROOFTOPUNIT + + +userdefined = IfcUnitaryEquipmentTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryEquipmentTypeEnum.NOTDEFINED + + +IfcValveTypeEnum = enum_namespace() + + +airrelease = IfcValveTypeEnum.AIRRELEASE + + +antivacuum = IfcValveTypeEnum.ANTIVACUUM + + +changeover = IfcValveTypeEnum.CHANGEOVER + + +check = IfcValveTypeEnum.CHECK + + +commissioning = IfcValveTypeEnum.COMMISSIONING + + +diverting = IfcValveTypeEnum.DIVERTING + + +drawoffcock = IfcValveTypeEnum.DRAWOFFCOCK + + +doublecheck = IfcValveTypeEnum.DOUBLECHECK + + +doubleregulating = IfcValveTypeEnum.DOUBLEREGULATING + + +faucet = IfcValveTypeEnum.FAUCET + + +flushing = IfcValveTypeEnum.FLUSHING + + +gascock = IfcValveTypeEnum.GASCOCK + + +gastap = IfcValveTypeEnum.GASTAP + + +isolating = IfcValveTypeEnum.ISOLATING + + +mixing = IfcValveTypeEnum.MIXING + + +pressurereducing = IfcValveTypeEnum.PRESSUREREDUCING + + +pressurerelief = IfcValveTypeEnum.PRESSURERELIEF + + +regulating = IfcValveTypeEnum.REGULATING + + +safetycutoff = IfcValveTypeEnum.SAFETYCUTOFF + + +steamtrap = IfcValveTypeEnum.STEAMTRAP + + +stopcock = IfcValveTypeEnum.STOPCOCK + + +userdefined = IfcValveTypeEnum.USERDEFINED + + +notdefined = IfcValveTypeEnum.NOTDEFINED + + +IfcVibrationDamperTypeEnum = enum_namespace() + + +bending_yield = IfcVibrationDamperTypeEnum.BENDING_YIELD + + +shear_yield = IfcVibrationDamperTypeEnum.SHEAR_YIELD + + +axial_yield = IfcVibrationDamperTypeEnum.AXIAL_YIELD + + +friction = IfcVibrationDamperTypeEnum.FRICTION + + +viscous = IfcVibrationDamperTypeEnum.VISCOUS + + +rubber = IfcVibrationDamperTypeEnum.RUBBER + + +userdefined = IfcVibrationDamperTypeEnum.USERDEFINED + + +notdefined = IfcVibrationDamperTypeEnum.NOTDEFINED + + +IfcVibrationIsolatorTypeEnum = enum_namespace() + + +compression = IfcVibrationIsolatorTypeEnum.COMPRESSION + + +spring = IfcVibrationIsolatorTypeEnum.SPRING + + +base = IfcVibrationIsolatorTypeEnum.BASE + + +userdefined = IfcVibrationIsolatorTypeEnum.USERDEFINED + + +notdefined = IfcVibrationIsolatorTypeEnum.NOTDEFINED + + +IfcVoidingFeatureTypeEnum = enum_namespace() + + +cutout = IfcVoidingFeatureTypeEnum.CUTOUT + + +notch = IfcVoidingFeatureTypeEnum.NOTCH + + +hole = IfcVoidingFeatureTypeEnum.HOLE + + +miter = IfcVoidingFeatureTypeEnum.MITER + + +chamfer = IfcVoidingFeatureTypeEnum.CHAMFER + + +edge = IfcVoidingFeatureTypeEnum.EDGE + + +userdefined = IfcVoidingFeatureTypeEnum.USERDEFINED + + +notdefined = IfcVoidingFeatureTypeEnum.NOTDEFINED + + +IfcWallTypeEnum = enum_namespace() + + +movable = IfcWallTypeEnum.MOVABLE + + +parapet = IfcWallTypeEnum.PARAPET + + +partitioning = IfcWallTypeEnum.PARTITIONING + + +plumbingwall = IfcWallTypeEnum.PLUMBINGWALL + + +shear = IfcWallTypeEnum.SHEAR + + +solidwall = IfcWallTypeEnum.SOLIDWALL + + +standard = IfcWallTypeEnum.STANDARD + + +polygonal = IfcWallTypeEnum.POLYGONAL + + +elementedwall = IfcWallTypeEnum.ELEMENTEDWALL + + +retainingwall = IfcWallTypeEnum.RETAININGWALL + + +wavewall = IfcWallTypeEnum.WAVEWALL + + +userdefined = IfcWallTypeEnum.USERDEFINED + + +notdefined = IfcWallTypeEnum.NOTDEFINED + + +IfcWasteTerminalTypeEnum = enum_namespace() + + +floortrap = IfcWasteTerminalTypeEnum.FLOORTRAP + + +floorwaste = IfcWasteTerminalTypeEnum.FLOORWASTE + + +gullysump = IfcWasteTerminalTypeEnum.GULLYSUMP + + +gullytrap = IfcWasteTerminalTypeEnum.GULLYTRAP + + +roofdrain = IfcWasteTerminalTypeEnum.ROOFDRAIN + + +wastedisposalunit = IfcWasteTerminalTypeEnum.WASTEDISPOSALUNIT + + +wastetrap = IfcWasteTerminalTypeEnum.WASTETRAP + + +userdefined = IfcWasteTerminalTypeEnum.USERDEFINED + + +notdefined = IfcWasteTerminalTypeEnum.NOTDEFINED + + +IfcWindowPanelOperationEnum = enum_namespace() + + +sidehungrighthand = IfcWindowPanelOperationEnum.SIDEHUNGRIGHTHAND + + +sidehunglefthand = IfcWindowPanelOperationEnum.SIDEHUNGLEFTHAND + + +tiltandturnrighthand = IfcWindowPanelOperationEnum.TILTANDTURNRIGHTHAND + + +tiltandturnlefthand = IfcWindowPanelOperationEnum.TILTANDTURNLEFTHAND + + +tophung = IfcWindowPanelOperationEnum.TOPHUNG + + +bottomhung = IfcWindowPanelOperationEnum.BOTTOMHUNG + + +pivothorizontal = IfcWindowPanelOperationEnum.PIVOTHORIZONTAL + + +pivotvertical = IfcWindowPanelOperationEnum.PIVOTVERTICAL + + +slidinghorizontal = IfcWindowPanelOperationEnum.SLIDINGHORIZONTAL + + +slidingvertical = IfcWindowPanelOperationEnum.SLIDINGVERTICAL + + +removablecasement = IfcWindowPanelOperationEnum.REMOVABLECASEMENT + + +fixedcasement = IfcWindowPanelOperationEnum.FIXEDCASEMENT + + +otheroperation = IfcWindowPanelOperationEnum.OTHEROPERATION + + +notdefined = IfcWindowPanelOperationEnum.NOTDEFINED + + +IfcWindowPanelPositionEnum = enum_namespace() + + +left = IfcWindowPanelPositionEnum.LEFT + + +middle = IfcWindowPanelPositionEnum.MIDDLE + + +right = IfcWindowPanelPositionEnum.RIGHT + + +bottom = IfcWindowPanelPositionEnum.BOTTOM + + +top = IfcWindowPanelPositionEnum.TOP + + +notdefined = IfcWindowPanelPositionEnum.NOTDEFINED + + +IfcWindowStyleConstructionEnum = enum_namespace() + + +aluminium = IfcWindowStyleConstructionEnum.ALUMINIUM + + +high_grade_steel = IfcWindowStyleConstructionEnum.HIGH_GRADE_STEEL + + +steel = IfcWindowStyleConstructionEnum.STEEL + + +wood = IfcWindowStyleConstructionEnum.WOOD + + +aluminium_wood = IfcWindowStyleConstructionEnum.ALUMINIUM_WOOD + + +plastic = IfcWindowStyleConstructionEnum.PLASTIC + + +other_construction = IfcWindowStyleConstructionEnum.OTHER_CONSTRUCTION + + +notdefined = IfcWindowStyleConstructionEnum.NOTDEFINED + + +IfcWindowStyleOperationEnum = enum_namespace() + + +single_panel = IfcWindowStyleOperationEnum.SINGLE_PANEL + + +double_panel_vertical = IfcWindowStyleOperationEnum.DOUBLE_PANEL_VERTICAL + + +double_panel_horizontal = IfcWindowStyleOperationEnum.DOUBLE_PANEL_HORIZONTAL + + +triple_panel_vertical = IfcWindowStyleOperationEnum.TRIPLE_PANEL_VERTICAL + + +triple_panel_bottom = IfcWindowStyleOperationEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_top = IfcWindowStyleOperationEnum.TRIPLE_PANEL_TOP + + +triple_panel_left = IfcWindowStyleOperationEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowStyleOperationEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_horizontal = IfcWindowStyleOperationEnum.TRIPLE_PANEL_HORIZONTAL + + +userdefined = IfcWindowStyleOperationEnum.USERDEFINED + + +notdefined = IfcWindowStyleOperationEnum.NOTDEFINED + + +IfcWindowTypeEnum = enum_namespace() + + +window = IfcWindowTypeEnum.WINDOW + + +skylight = IfcWindowTypeEnum.SKYLIGHT + + +lightdome = IfcWindowTypeEnum.LIGHTDOME + + +userdefined = IfcWindowTypeEnum.USERDEFINED + + +notdefined = IfcWindowTypeEnum.NOTDEFINED + + +IfcWindowTypePartitioningEnum = enum_namespace() + + +single_panel = IfcWindowTypePartitioningEnum.SINGLE_PANEL + + +double_panel_vertical = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_VERTICAL + + +double_panel_horizontal = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_HORIZONTAL + + +triple_panel_vertical = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_VERTICAL + + +triple_panel_bottom = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_top = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_TOP + + +triple_panel_left = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_horizontal = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_HORIZONTAL + + +userdefined = IfcWindowTypePartitioningEnum.USERDEFINED + + +notdefined = IfcWindowTypePartitioningEnum.NOTDEFINED + + +IfcWorkCalendarTypeEnum = enum_namespace() + + +firstshift = IfcWorkCalendarTypeEnum.FIRSTSHIFT + + +secondshift = IfcWorkCalendarTypeEnum.SECONDSHIFT + + +thirdshift = IfcWorkCalendarTypeEnum.THIRDSHIFT + + +userdefined = IfcWorkCalendarTypeEnum.USERDEFINED + + +notdefined = IfcWorkCalendarTypeEnum.NOTDEFINED + + +IfcWorkPlanTypeEnum = enum_namespace() + + +actual = IfcWorkPlanTypeEnum.ACTUAL + + +baseline = IfcWorkPlanTypeEnum.BASELINE + + +planned = IfcWorkPlanTypeEnum.PLANNED + + +userdefined = IfcWorkPlanTypeEnum.USERDEFINED + + +notdefined = IfcWorkPlanTypeEnum.NOTDEFINED + + +IfcWorkScheduleTypeEnum = enum_namespace() + + +actual = IfcWorkScheduleTypeEnum.ACTUAL + + +baseline = IfcWorkScheduleTypeEnum.BASELINE + + +planned = IfcWorkScheduleTypeEnum.PLANNED + + +userdefined = IfcWorkScheduleTypeEnum.USERDEFINED + + +notdefined = IfcWorkScheduleTypeEnum.NOTDEFINED + + +def IfcActionRequest(*args, **kwargs): return ifcopenshell.create_entity('IfcActionRequest', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcActor(*args, **kwargs): return ifcopenshell.create_entity('IfcActor', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcActorRole(*args, **kwargs): return ifcopenshell.create_entity('IfcActorRole', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcActuator(*args, **kwargs): return ifcopenshell.create_entity('IfcActuator', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcActuatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcActuatorType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcAddress', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAdvancedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrep', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAdvancedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrepWithVoids', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAdvancedFace(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedFace', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAirTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminal', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAirTerminalBox(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBox', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAirTerminalBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBoxType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAirTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAirToAirHeatRecovery(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecovery', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAirToAirHeatRecoveryType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecoveryType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAlarm(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarm', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAlarmType(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarmType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAlignment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAlignmentCant(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCant', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAlignmentCantSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCantSegment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAlignmentHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentHorizontal', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAlignmentHorizontalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentHorizontalSegment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAlignmentParameterSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentParameterSegment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAlignmentSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentSegment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAlignmentVertical(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentVertical', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAlignmentVerticalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentVerticalSegment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAnnotation(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotation', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAnnotationFillArea(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationFillArea', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcApplication(*args, **kwargs): return ifcopenshell.create_entity('IfcApplication', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAppliedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcAppliedValue', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcApproval', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcApprovalRelationship', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcArbitraryClosedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryClosedProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcArbitraryOpenProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryOpenProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcArbitraryProfileDefWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryProfileDefWithVoids', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAsset(*args, **kwargs): return ifcopenshell.create_entity('IfcAsset', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAsymmetricIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcAsymmetricIShapeProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAudioVisualAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualAppliance', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAudioVisualApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualApplianceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAxis1Placement(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis1Placement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAxis2Placement2D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement2D', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAxis2Placement3D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement3D', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcAxis2PlacementLinear(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2PlacementLinear', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBSplineCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurveWithKnots', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBSplineSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurface', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurfaceWithKnots', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcBeam', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBeamStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamStandardCase', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBearing(*args, **kwargs): return ifcopenshell.create_entity('IfcBearing', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBearingType(*args, **kwargs): return ifcopenshell.create_entity('IfcBearingType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBlobTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcBlobTexture', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBlock(*args, **kwargs): return ifcopenshell.create_entity('IfcBlock', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBoiler(*args, **kwargs): return ifcopenshell.create_entity('IfcBoiler', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBoilerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBoilerType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBooleanClippingResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanClippingResult', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBooleanResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanResult', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBorehole(*args, **kwargs): return ifcopenshell.create_entity('IfcBorehole', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBoundaryCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCondition', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBoundaryEdgeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryEdgeCondition', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBoundaryFaceCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryFaceCondition', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBoundaryNodeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeCondition', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBoundaryNodeConditionWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeConditionWarping', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBoundedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedSurface', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBoundingBox(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundingBox', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBoxedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcBoxedHalfSpace', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBridge(*args, **kwargs): return ifcopenshell.create_entity('IfcBridge', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBuilding(*args, **kwargs): return ifcopenshell.create_entity('IfcBuilding', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBuildingElementPart(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPart', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBuildingElementPartType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPartType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBuildingElementProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxy', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBuildingElementProxyType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxyType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBuildingStorey(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingStorey', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBuildingSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingSystem', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBuiltElement(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBuiltElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBuiltSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltSystem', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBurner(*args, **kwargs): return ifcopenshell.create_entity('IfcBurner', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcBurnerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBurnerType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCShapeProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCableCarrierFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFitting', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCableCarrierFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFittingType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCableCarrierSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCableCarrierSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegmentType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCableFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFitting', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCableFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFittingType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCableSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCableSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegmentType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCaissonFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundation', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCaissonFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundationType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCartesianPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPoint', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCartesianPointList(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCartesianPointList2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList2D', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCartesianPointList3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList3D', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCartesianTransformationOperator(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCartesianTransformationOperator2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2D', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCartesianTransformationOperator2DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2DnonUniform', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCartesianTransformationOperator3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3D', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCartesianTransformationOperator3DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3DnonUniform', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCenterLineProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCenterLineProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcChiller(*args, **kwargs): return ifcopenshell.create_entity('IfcChiller', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcChillerType(*args, **kwargs): return ifcopenshell.create_entity('IfcChillerType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcChimney(*args, **kwargs): return ifcopenshell.create_entity('IfcChimney', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcChimneyType(*args, **kwargs): return ifcopenshell.create_entity('IfcChimneyType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCircle(*args, **kwargs): return ifcopenshell.create_entity('IfcCircle', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCircleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleHollowProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCircleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCivilElement(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCivilElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcClassification', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcClassificationReference(*args, **kwargs): return ifcopenshell.create_entity('IfcClassificationReference', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcClosedShell(*args, **kwargs): return ifcopenshell.create_entity('IfcClosedShell', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcClothoid(*args, **kwargs): return ifcopenshell.create_entity('IfcClothoid', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCoil(*args, **kwargs): return ifcopenshell.create_entity('IfcCoil', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCoilType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoilType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcColourRgb(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgb', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcColourRgbList(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgbList', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcColourSpecification(*args, **kwargs): return ifcopenshell.create_entity('IfcColourSpecification', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcColumn', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcColumnStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnStandardCase', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcColumnType(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsAppliance', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsApplianceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcComplexProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexProperty', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcComplexPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexPropertyTemplate', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCompositeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCompositeCurveOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveOnSurface', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveSegment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCompositeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCompressor(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressor', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCompressorType(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressorType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCondenser(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenser', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCondenserType(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenserType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConic(*args, **kwargs): return ifcopenshell.create_entity('IfcConic', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConnectedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectedFaceSet', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConnectionCurveGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionCurveGeometry', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConnectionGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionGeometry', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConnectionPointEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointEccentricity', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConnectionPointGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointGeometry', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConnectionSurfaceGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionSurfaceGeometry', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConnectionVolumeGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionVolumeGeometry', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcConstraint', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConstructionEquipmentResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResource', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConstructionEquipmentResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResourceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConstructionMaterialResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResource', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConstructionMaterialResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResourceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConstructionProductResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResource', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConstructionProductResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResourceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConstructionResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResource', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConstructionResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResourceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcContext(*args, **kwargs): return ifcopenshell.create_entity('IfcContext', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcContextDependentUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcContextDependentUnit', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcControl(*args, **kwargs): return ifcopenshell.create_entity('IfcControl', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcController(*args, **kwargs): return ifcopenshell.create_entity('IfcController', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcControllerType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConversionBasedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnit', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConversionBasedUnitWithOffset(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnitWithOffset', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConveyorSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcConveyorSegment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcConveyorSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcConveyorSegmentType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCooledBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeam', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCooledBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeamType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCoolingTower(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTower', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCoolingTowerType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTowerType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCoordinateOperation(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateOperation', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCoordinateReferenceSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateReferenceSystem', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCosine(*args, **kwargs): return ifcopenshell.create_entity('IfcCosine', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCostItem(*args, **kwargs): return ifcopenshell.create_entity('IfcCostItem', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCostSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcCostSchedule', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCostValue(*args, **kwargs): return ifcopenshell.create_entity('IfcCostValue', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCourse(*args, **kwargs): return ifcopenshell.create_entity('IfcCourse', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCourseType(*args, **kwargs): return ifcopenshell.create_entity('IfcCourseType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCovering(*args, **kwargs): return ifcopenshell.create_entity('IfcCovering', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCoveringType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoveringType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCrewResource(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResource', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCrewResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResourceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCsgPrimitive3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgPrimitive3D', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCsgSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgSolid', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCurrencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcCurrencyRelationship', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCurtainWall(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWall', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCurtainWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWallType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCurveBoundedPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedPlane', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCurveBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedSurface', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveSegment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCurveStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyle', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCurveStyleFont(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFont', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCurveStyleFontAndScaling(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontAndScaling', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCurveStyleFontPattern(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontPattern', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcCylindricalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCylindricalSurface', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcDamper', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcDamperType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDeepFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundation', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDeepFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundationType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDerivedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDerivedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnit', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDerivedUnitElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnitElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDimensionalExponents(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionalExponents', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDirection(*args, **kwargs): return ifcopenshell.create_entity('IfcDirection', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDirectrixCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcDirectrixCurveSweptAreaSolid', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDirectrixDerivedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcDirectrixDerivedReferenceSweptAreaSolid', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDiscreteAccessory(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessory', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDiscreteAccessoryType(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessoryType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionBoard', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionBoardType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDistributionChamberElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDistributionChamberElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDistributionCircuit(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionCircuit', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDistributionControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDistributionControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDistributionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDistributionElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDistributionFlowElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDistributionFlowElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDistributionPort(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionPort', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDistributionSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionSystem', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDocumentInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformation', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDocumentInformationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformationRelationship', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDocumentReference(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentReference', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDoor(*args, **kwargs): return ifcopenshell.create_entity('IfcDoor', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDoorLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorLiningProperties', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDoorPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorPanelProperties', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDoorStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorStandardCase', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDoorStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorStyle', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDoorType(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDraughtingPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedColour', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDraughtingPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedCurveFont', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDuctFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFitting', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDuctFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFittingType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDuctSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDuctSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegmentType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDuctSilencer(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencer', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcDuctSilencerType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencerType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEarthworksCut(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksCut', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEarthworksElement(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEarthworksFill(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksFill', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcEdge', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEdgeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEdgeLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeLoop', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElectricAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricAppliance', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElectricApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricApplianceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElectricDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoard', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElectricDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoardType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElectricFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDevice', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElectricFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDeviceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElectricFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowTreatmentDevice', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElectricFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowTreatmentDeviceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElectricGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGenerator', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElectricGeneratorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGeneratorType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElectricMotor(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotor', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElectricMotorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotorType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElectricTimeControl(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControl', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElectricTimeControlType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControlType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElement(*args, **kwargs): return ifcopenshell.create_entity('IfcElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElementAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssembly', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElementAssemblyType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssemblyType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElementComponent(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponent', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElementComponentType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponentType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElementQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcElementQuantity', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcElementarySurface(*args, **kwargs): return ifcopenshell.create_entity('IfcElementarySurface', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEllipse(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipse', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEllipseProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipseProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEnergyConversionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDevice', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEnergyConversionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDeviceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEngine(*args, **kwargs): return ifcopenshell.create_entity('IfcEngine', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEngineType(*args, **kwargs): return ifcopenshell.create_entity('IfcEngineType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEvaporativeCooler(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCooler', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEvaporativeCoolerType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCoolerType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEvaporator(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporator', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEvaporatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporatorType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEvent(*args, **kwargs): return ifcopenshell.create_entity('IfcEvent', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEventTime(*args, **kwargs): return ifcopenshell.create_entity('IfcEventTime', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcEventType(*args, **kwargs): return ifcopenshell.create_entity('IfcEventType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcExtendedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcExtendedProperties', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcExternalInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalInformation', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcExternalReference(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReference', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcExternalReferenceRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReferenceRelationship', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcExternalSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcExternalSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialStructureElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcExternallyDefinedHatchStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedHatchStyle', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcExternallyDefinedSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedSurfaceStyle', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcExternallyDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedTextFont', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcExtrudedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolid', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcExtrudedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolidTapered', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFace(*args, **kwargs): return ifcopenshell.create_entity('IfcFace', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFaceBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBasedSurfaceModel', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFaceBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBound', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFaceOuterBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceOuterBound', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFaceSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceSurface', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFacetedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrep', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFacetedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrepWithVoids', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFacility(*args, **kwargs): return ifcopenshell.create_entity('IfcFacility', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFacilityPart(*args, **kwargs): return ifcopenshell.create_entity('IfcFacilityPart', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFailureConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcFailureConnectionCondition', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFan(*args, **kwargs): return ifcopenshell.create_entity('IfcFan', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFanType(*args, **kwargs): return ifcopenshell.create_entity('IfcFanType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcFastener', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFastenerType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFeatureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFeatureElementAddition(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementAddition', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFeatureElementSubtraction(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementSubtraction', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFillAreaStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyle', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFillAreaStyleHatching(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleHatching', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFillAreaStyleTiles(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleTiles', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFilter(*args, **kwargs): return ifcopenshell.create_entity('IfcFilter', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFilterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFilterType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFireSuppressionTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminal', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFireSuppressionTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminalType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFixedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcFixedReferenceSweptAreaSolid', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowController(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowController', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowControllerType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFitting', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFittingType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowInstrument(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrument', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowInstrumentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrumentType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowMeter(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeter', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowMeterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeterType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowMovingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDevice', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowMovingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDeviceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegmentType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDevice', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDeviceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminal', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminalType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDevice', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDeviceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFooting(*args, **kwargs): return ifcopenshell.create_entity('IfcFooting', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFootingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFootingType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFurnishingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFurnishingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFurniture(*args, **kwargs): return ifcopenshell.create_entity('IfcFurniture', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcFurnitureType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnitureType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGeographicElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGeographicElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGeometricCurveSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricCurveSet', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGeometricRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationContext', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGeometricRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationItem', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGeometricRepresentationSubContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationSubContext', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGeometricSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricSet', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGeomodel(*args, **kwargs): return ifcopenshell.create_entity('IfcGeomodel', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGeoslice(*args, **kwargs): return ifcopenshell.create_entity('IfcGeoslice', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGeotechnicalAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalAssembly', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGeotechnicalElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGeotechnicalStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalStratum', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGradientCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcGradientCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGrid(*args, **kwargs): return ifcopenshell.create_entity('IfcGrid', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGridAxis(*args, **kwargs): return ifcopenshell.create_entity('IfcGridAxis', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGridPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcGridPlacement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcGroup', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcHalfSpaceSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcHalfSpaceSolid', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcHeatExchanger(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchanger', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcHeatExchangerType(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchangerType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcHumidifier(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifier', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcHumidifierType(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifierType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcIShapeProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcImageTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcImageTexture', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcImpactProtectionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcImpactProtectionDevice', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcImpactProtectionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcImpactProtectionDeviceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcIndexedColourMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedColourMap', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcIndexedPolyCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolyCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcIndexedPolygonalFace(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFace', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcIndexedPolygonalFaceWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFaceWithVoids', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcIndexedTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTextureMap', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcIndexedTriangleTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTriangleTextureMap', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcInterceptor(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptor', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcInterceptorType(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptorType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcIntersectionCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIntersectionCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcInventory(*args, **kwargs): return ifcopenshell.create_entity('IfcInventory', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcIrregularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeries', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcIrregularTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeriesValue', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcJunctionBox(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBox', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcJunctionBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBoxType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcKerb(*args, **kwargs): return ifcopenshell.create_entity('IfcKerb', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcKerbType(*args, **kwargs): return ifcopenshell.create_entity('IfcKerbType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcLShapeProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLaborResource(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResource', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLaborResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResourceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLagTime(*args, **kwargs): return ifcopenshell.create_entity('IfcLagTime', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLamp(*args, **kwargs): return ifcopenshell.create_entity('IfcLamp', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLampType(*args, **kwargs): return ifcopenshell.create_entity('IfcLampType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLibraryInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryInformation', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLibraryReference(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryReference', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLightDistributionData(*args, **kwargs): return ifcopenshell.create_entity('IfcLightDistributionData', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLightFixture(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixture', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLightFixtureType(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixtureType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLightIntensityDistribution(*args, **kwargs): return ifcopenshell.create_entity('IfcLightIntensityDistribution', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLightSource(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSource', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLightSourceAmbient(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceAmbient', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLightSourceDirectional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceDirectional', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLightSourceGoniometric(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceGoniometric', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLightSourcePositional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourcePositional', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLightSourceSpot(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceSpot', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLine(*args, **kwargs): return ifcopenshell.create_entity('IfcLine', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLinearElement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLinearPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPlacement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLinearPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPositioningElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLiquidTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcLiquidTerminal', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLiquidTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcLiquidTerminalType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLocalPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLocalPlacement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcLoop', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcManifoldSolidBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcManifoldSolidBrep', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMapConversion(*args, **kwargs): return ifcopenshell.create_entity('IfcMapConversion', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMappedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcMappedItem', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMarineFacility(*args, **kwargs): return ifcopenshell.create_entity('IfcMarineFacility', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterial', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialClassificationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialClassificationRelationship', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialConstituent(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituent', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialConstituentSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituentSet', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinition', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialDefinitionRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinitionRepresentation', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialLayer(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayer', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialLayerSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSet', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialLayerSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSetUsage', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialLayerWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerWithOffsets', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialList(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialList', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialProfile(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfile', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialProfileSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSet', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialProfileSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsage', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialProfileSetUsageTapering(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsageTapering', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialProfileWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileWithOffsets', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProperties', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialRelationship', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMaterialUsageDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialUsageDefinition', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMeasureWithUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMeasureWithUnit', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMechanicalFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastener', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMechanicalFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastenerType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMedicalDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDevice', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMedicalDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDeviceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMember(*args, **kwargs): return ifcopenshell.create_entity('IfcMember', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMemberStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberStandardCase', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMemberType(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMetric(*args, **kwargs): return ifcopenshell.create_entity('IfcMetric', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMirroredProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcMirroredProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMobileTelecommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcMobileTelecommunicationsAppliance', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMobileTelecommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMobileTelecommunicationsApplianceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMonetaryUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMonetaryUnit', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMooringDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMooringDevice', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMooringDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMooringDeviceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMotorConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnection', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcMotorConnectionType(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnectionType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcNamedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcNamedUnit', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcNavigationElement(*args, **kwargs): return ifcopenshell.create_entity('IfcNavigationElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcNavigationElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcNavigationElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcObject(*args, **kwargs): return ifcopenshell.create_entity('IfcObject', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcObjectDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectDefinition', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcObjectPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectPlacement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcObjective(*args, **kwargs): return ifcopenshell.create_entity('IfcObjective', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOccupant(*args, **kwargs): return ifcopenshell.create_entity('IfcOccupant', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOffsetCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOffsetCurve2D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve2D', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOffsetCurve3D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve3D', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOffsetCurveByDistances(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurveByDistances', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOpenCrossProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenCrossProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOpenShell(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenShell', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOpeningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOpeningStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningStandardCase', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganization', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOrganizationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganizationRelationship', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOrientedEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcOrientedEdge', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOuterBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOuterBoundaryCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOutlet(*args, **kwargs): return ifcopenshell.create_entity('IfcOutlet', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOutletType(*args, **kwargs): return ifcopenshell.create_entity('IfcOutletType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcOwnerHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcOwnerHistory', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcParameterizedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcParameterizedProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPath(*args, **kwargs): return ifcopenshell.create_entity('IfcPath', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPavement(*args, **kwargs): return ifcopenshell.create_entity('IfcPavement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPavementType(*args, **kwargs): return ifcopenshell.create_entity('IfcPavementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPcurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPcurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPerformanceHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcPerformanceHistory', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPermeableCoveringProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPermeableCoveringProperties', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPermit(*args, **kwargs): return ifcopenshell.create_entity('IfcPermit', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPerson(*args, **kwargs): return ifcopenshell.create_entity('IfcPerson', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPersonAndOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcPersonAndOrganization', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPhysicalComplexQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalComplexQuantity', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPhysicalQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalQuantity', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPhysicalSimpleQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalSimpleQuantity', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPile(*args, **kwargs): return ifcopenshell.create_entity('IfcPile', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPileType(*args, **kwargs): return ifcopenshell.create_entity('IfcPileType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPipeFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFitting', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPipeFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFittingType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPipeSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPipeSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegmentType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPixelTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcPixelTexture', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcPlacement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPlanarBox(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarBox', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPlanarExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarExtent', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcPlane', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPlant(*args, **kwargs): return ifcopenshell.create_entity('IfcPlant', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPlate(*args, **kwargs): return ifcopenshell.create_entity('IfcPlate', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPlateStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateStandardCase', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPlateType(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcPoint', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPointByDistanceExpression(*args, **kwargs): return ifcopenshell.create_entity('IfcPointByDistanceExpression', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPointOnCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPointOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnSurface', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPolyLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyLoop', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPolygonalBoundedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalBoundedHalfSpace', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPolygonalFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalFaceSet', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPolyline(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyline', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPolynomialCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPolynomialCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPort(*args, **kwargs): return ifcopenshell.create_entity('IfcPort', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcPositioningElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPostalAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcPostalAddress', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedColour', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedCurveFont', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPreDefinedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedItem', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPreDefinedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedProperties', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPreDefinedPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedPropertySet', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPreDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedTextFont', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationItem', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPresentationLayerAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerAssignment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPresentationLayerWithStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerWithStyle', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPresentationStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyle', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProcedure(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedure', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProcedureType(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedureType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcProcess', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcProduct', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProductDefinitionShape(*args, **kwargs): return ifcopenshell.create_entity('IfcProductDefinitionShape', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProductRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcProductRepresentation', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileProperties', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProject(*args, **kwargs): return ifcopenshell.create_entity('IfcProject', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProjectLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectLibrary', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProjectOrder(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectOrder', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProjectedCRS(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectedCRS', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProjectionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectionElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcProperty', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPropertyAbstraction(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyAbstraction', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPropertyBoundedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyBoundedValue', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPropertyDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDefinition', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPropertyDependencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDependencyRelationship', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPropertyEnumeratedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeratedValue', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPropertyEnumeration(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeration', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPropertyListValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyListValue', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPropertyReferenceValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyReferenceValue', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySet', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPropertySetDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetDefinition', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPropertySetTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetTemplate', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPropertySingleValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySingleValue', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPropertyTableValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTableValue', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplate', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPropertyTemplateDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplateDefinition', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProtectiveDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDevice', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnit', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnitType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnitType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProtectiveDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcProxy', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPump(*args, **kwargs): return ifcopenshell.create_entity('IfcPump', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcPumpType(*args, **kwargs): return ifcopenshell.create_entity('IfcPumpType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcQuantityArea(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityArea', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcQuantityCount(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityCount', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcQuantityLength(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityLength', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcQuantitySet(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantitySet', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcQuantityTime(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityTime', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcQuantityVolume(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityVolume', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcQuantityWeight(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityWeight', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRail(*args, **kwargs): return ifcopenshell.create_entity('IfcRail', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRailType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRailing(*args, **kwargs): return ifcopenshell.create_entity('IfcRailing', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRailingType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailingType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRailway(*args, **kwargs): return ifcopenshell.create_entity('IfcRailway', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRamp(*args, **kwargs): return ifcopenshell.create_entity('IfcRamp', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRampFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlight', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRampFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlightType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRampType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRationalBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineCurveWithKnots', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRationalBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineSurfaceWithKnots', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRectangleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleHollowProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRectangularPyramid(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularPyramid', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRectangularTrimmedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularTrimmedSurface', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRecurrencePattern(*args, **kwargs): return ifcopenshell.create_entity('IfcRecurrencePattern', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcReference(*args, **kwargs): return ifcopenshell.create_entity('IfcReference', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcReferent(*args, **kwargs): return ifcopenshell.create_entity('IfcReferent', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRegularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcRegularTimeSeries', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcReinforcedSoil(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcedSoil', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcReinforcementBarProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementBarProperties', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcReinforcementDefinitionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementDefinitionProperties', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcReinforcingBar(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBar', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcReinforcingBarType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBarType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcReinforcingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcReinforcingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcReinforcingMesh(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMesh', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcReinforcingMeshType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMeshType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAdheresToElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAdheresToElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAggregates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAggregates', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssigns(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssigns', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssignsToActor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToActor', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssignsToControl(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToControl', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssignsToGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroup', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssignsToGroupByFactor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroupByFactor', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssignsToProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProcess', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssignsToProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProduct', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssignsToResource(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToResource', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssociates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociates', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssociatesApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesApproval', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssociatesClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesClassification', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssociatesConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesConstraint', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssociatesDocument(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesDocument', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssociatesLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesLibrary', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssociatesMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesMaterial', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelAssociatesProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelConnects(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnects', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelConnectsElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsElements', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelConnectsPathElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPathElements', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelConnectsPortToElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPortToElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelConnectsPorts(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPorts', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelConnectsStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralActivity', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelConnectsStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralMember', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelConnectsWithEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithEccentricity', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelConnectsWithRealizingElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithRealizingElements', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelContainedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelContainedInSpatialStructure', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelCoversBldgElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversBldgElements', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelCoversSpaces(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversSpaces', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelDeclares(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDeclares', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelDecomposes(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDecomposes', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelDefines(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefines', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelDefinesByObject(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByObject', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelDefinesByProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByProperties', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelDefinesByTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByTemplate', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelDefinesByType(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelFillsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFillsElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelFlowControlElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFlowControlElements', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelInterferesElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelInterferesElements', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelNests(*args, **kwargs): return ifcopenshell.create_entity('IfcRelNests', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelPositions(*args, **kwargs): return ifcopenshell.create_entity('IfcRelPositions', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelProjectsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelProjectsElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelReferencedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelReferencedInSpatialStructure', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelSequence(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSequence', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelServicesBuildings(*args, **kwargs): return ifcopenshell.create_entity('IfcRelServicesBuildings', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelSpaceBoundary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelSpaceBoundary1stLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary1stLevel', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelSpaceBoundary2ndLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary2ndLevel', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelVoidsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelVoidsElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcRelationship', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcReparametrisedCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcReparametrisedCompositeCurveSegment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentation', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationContext', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationItem', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRepresentationMap(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationMap', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcResource(*args, **kwargs): return ifcopenshell.create_entity('IfcResource', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcResourceApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceApprovalRelationship', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcResourceConstraintRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceConstraintRelationship', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcResourceLevelRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceLevelRelationship', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcResourceTime(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceTime', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRevolvedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolid', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRevolvedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolidTapered', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRightCircularCone(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCone', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRightCircularCylinder(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCylinder', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRoad(*args, **kwargs): return ifcopenshell.create_entity('IfcRoad', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRoof(*args, **kwargs): return ifcopenshell.create_entity('IfcRoof', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRoofType(*args, **kwargs): return ifcopenshell.create_entity('IfcRoofType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRoot(*args, **kwargs): return ifcopenshell.create_entity('IfcRoot', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcRoundedRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRoundedRectangleProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSIUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcSIUnit', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSanitaryTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminal', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSanitaryTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminalType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSchedulingTime(*args, **kwargs): return ifcopenshell.create_entity('IfcSchedulingTime', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSeamCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSeamCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSecondOrderPolynomialSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSecondOrderPolynomialSpiral', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSectionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionProperties', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSectionReinforcementProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionReinforcementProperties', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSectionedSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolid', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSectionedSolidHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolidHorizontal', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSectionedSpine(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSpine', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSectionedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSurface', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcSegment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSegmentedReferenceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSegmentedReferenceCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSensor(*args, **kwargs): return ifcopenshell.create_entity('IfcSensor', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSensorType(*args, **kwargs): return ifcopenshell.create_entity('IfcSensorType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSeventhOrderPolynomialSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSeventhOrderPolynomialSpiral', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcShadingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDevice', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcShadingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDeviceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcShapeAspect(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeAspect', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcShapeModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeModel', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcShapeRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeRepresentation', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcShellBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShellBasedSurfaceModel', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSign(*args, **kwargs): return ifcopenshell.create_entity('IfcSign', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSignType(*args, **kwargs): return ifcopenshell.create_entity('IfcSignType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSignal(*args, **kwargs): return ifcopenshell.create_entity('IfcSignal', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSignalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSignalType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSimpleProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcSimpleProperty', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSimplePropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcSimplePropertyTemplate', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSine(*args, **kwargs): return ifcopenshell.create_entity('IfcSine', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSite(*args, **kwargs): return ifcopenshell.create_entity('IfcSite', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSlab(*args, **kwargs): return ifcopenshell.create_entity('IfcSlab', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSlabElementedCase(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabElementedCase', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSlabStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabStandardCase', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSlabType(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSlippageConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcSlippageConnectionCondition', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSolarDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDevice', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSolarDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDeviceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSolidModel(*args, **kwargs): return ifcopenshell.create_entity('IfcSolidModel', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSolidStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcSolidStratum', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcSpace', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSpaceHeater(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeater', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSpaceHeaterType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeaterType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSpaceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSpatialElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSpatialStructureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSpatialZone(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZone', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSpatialZoneType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZoneType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSphere(*args, **kwargs): return ifcopenshell.create_entity('IfcSphere', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSphericalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSphericalSurface', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSpiral', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStackTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminal', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStackTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminalType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStair(*args, **kwargs): return ifcopenshell.create_entity('IfcStair', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStairFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlight', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStairFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlightType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStairType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAction', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralActivity', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralAnalysisModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAnalysisModel', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnection', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnectionCondition', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralCurveAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveAction', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralCurveConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveConnection', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralCurveMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMember', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralCurveMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMemberVarying', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralCurveReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveReaction', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralItem', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralLinearAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLinearAction', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralLoad(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoad', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralLoadCase(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadCase', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralLoadConfiguration(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadConfiguration', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralLoadGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadGroup', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralLoadLinearForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadLinearForce', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralLoadOrResult(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadOrResult', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralLoadPlanarForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadPlanarForce', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacement(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacementDistortion(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacementDistortion', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralLoadSingleForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForce', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralLoadSingleForceWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForceWarping', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralLoadStatic(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadStatic', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralLoadTemperature(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadTemperature', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralMember', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralPlanarAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPlanarAction', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralPointAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointAction', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralPointConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointConnection', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralPointReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointReaction', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralReaction', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralResultGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralResultGroup', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralSurfaceAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceAction', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralSurfaceConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceConnection', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralSurfaceMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMember', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralSurfaceMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMemberVarying', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStructuralSurfaceReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceReaction', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStyleModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStyleModel', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStyledItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledItem', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcStyledRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledRepresentation', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSubContractResource(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResource', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSubContractResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResourceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSubedge(*args, **kwargs): return ifcopenshell.create_entity('IfcSubedge', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSurface', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSurfaceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSurfaceCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurveSweptAreaSolid', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSurfaceFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceFeature', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSurfaceOfLinearExtrusion(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfLinearExtrusion', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSurfaceOfRevolution(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfRevolution', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSurfaceReinforcementArea(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceReinforcementArea', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyle', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSurfaceStyleLighting(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleLighting', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSurfaceStyleRefraction(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRefraction', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSurfaceStyleRendering(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRendering', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSurfaceStyleShading(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleShading', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSurfaceStyleWithTextures(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleWithTextures', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSurfaceTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceTexture', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptAreaSolid', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSweptDiskSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolid', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSweptDiskSolidPolygonal(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolidPolygonal', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSweptSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptSurface', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSwitchingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDevice', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSwitchingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDeviceType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcSystem', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSystemFurnitureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcSystemFurnitureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTShapeProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTable(*args, **kwargs): return ifcopenshell.create_entity('IfcTable', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTableColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcTableColumn', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTableRow(*args, **kwargs): return ifcopenshell.create_entity('IfcTableRow', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTank(*args, **kwargs): return ifcopenshell.create_entity('IfcTank', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTankType(*args, **kwargs): return ifcopenshell.create_entity('IfcTankType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTask(*args, **kwargs): return ifcopenshell.create_entity('IfcTask', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTaskTime(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTime', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTaskTimeRecurring(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTimeRecurring', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTaskType(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTelecomAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcTelecomAddress', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTendon(*args, **kwargs): return ifcopenshell.create_entity('IfcTendon', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTendonAnchor(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchor', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTendonAnchorType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchorType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTendonConduit(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduit', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTendonConduitType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduitType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTendonType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTessellatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedFaceSet', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTessellatedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedItem', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTextLiteral(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteral', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTextLiteralWithExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteralWithExtent', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTextStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyle', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTextStyleFontModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleFontModel', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTextStyleForDefinedFont(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleForDefinedFont', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTextStyleTextModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleTextModel', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTextureCoordinate(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinate', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTextureCoordinateGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateGenerator', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureMap', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTextureVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertex', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTextureVertexList(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertexList', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcThirdOrderPolynomialSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcThirdOrderPolynomialSpiral', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTimePeriod(*args, **kwargs): return ifcopenshell.create_entity('IfcTimePeriod', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeries', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeriesValue', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTopologicalRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologicalRepresentationItem', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTopologyRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologyRepresentation', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcToroidalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcToroidalSurface', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTrackElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTrackElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTrackElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTrackElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTransformer(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformer', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTransformerType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformerType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTransportElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTransportElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTrapeziumProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTrapeziumProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTriangulatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedFaceSet', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTriangulatedIrregularNetwork(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedIrregularNetwork', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTrimmedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcTrimmedCurve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTubeBundle(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundle', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTubeBundleType(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundleType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTypeObject(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeObject', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTypeProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProcess', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTypeProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProduct', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcTypeResource(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeResource', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcUShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcUShapeProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcUnitAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitAssignment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcUnitaryControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcUnitaryControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElementType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcUnitaryEquipment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipment', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcUnitaryEquipmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipmentType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcValve(*args, **kwargs): return ifcopenshell.create_entity('IfcValve', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcValveType(*args, **kwargs): return ifcopenshell.create_entity('IfcValveType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcVector(*args, **kwargs): return ifcopenshell.create_entity('IfcVector', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcVertex', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcVertexLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexLoop', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcVertexPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexPoint', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcVibrationDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamper', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcVibrationDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamperType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcVibrationIsolator(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolator', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcVibrationIsolatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolatorType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcVirtualElement(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualElement', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcVirtualGridIntersection(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualGridIntersection', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcVoidStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcVoidStratum', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcVoidingFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcVoidingFeature', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWall(*args, **kwargs): return ifcopenshell.create_entity('IfcWall', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWallElementedCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallElementedCase', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWallStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallStandardCase', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcWallType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWasteTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminal', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWasteTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminalType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWaterStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcWaterStratum', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWindow(*args, **kwargs): return ifcopenshell.create_entity('IfcWindow', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWindowLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowLiningProperties', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWindowPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowPanelProperties', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWindowStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowStandardCase', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWindowStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowStyle', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWindowType(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowType', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWorkCalendar(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkCalendar', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWorkControl(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkControl', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWorkPlan(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkPlan', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWorkSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkSchedule', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcWorkTime(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkTime', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcZShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcZShapeProfileDef', 'IFC4X3_RC4', *args, **kwargs) + + +def IfcZone(*args, **kwargs): return ifcopenshell.create_entity('IfcZone', 'IFC4X3_RC4', *args, **kwargs) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcBoxAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcBoxAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['top-left','top-middle','top-right','middle-left','center','middle-right','bottom-left','bottom-middle','bottom-right'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCardinalPointReference_GreaterThanZero: + SCOPE = "type" + TYPE_NAME = "IfcCardinalPointReference" + RULE_NAME = "GreaterThanZero" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCompoundPlaneAngleMeasure_MinutesInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MinutesInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[2 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_SecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "SecondsInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[3 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_MicrosecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MicrosecondsInRange" + + @staticmethod + def __call__(self): + + + assert (sizeof(self) == 3) or ((abs(self[4 - 1])) < 1000000) + + + + +class IfcCompoundPlaneAngleMeasure_ConsistentSign: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "ConsistentSign" + + @staticmethod + def __call__(self): + + + assert (((self[1 - 1]) >= 0) and ((self[2 - 1]) >= 0) and ((self[3 - 1]) >= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) >= 0))) or (((self[1 - 1]) <= 0) and ((self[2 - 1]) <= 0) and ((self[3 - 1]) <= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) <= 0))) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDayInMonthNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInMonthNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 31 + + + + + +class IfcDayInWeekNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInWeekNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 7 + + + + + + + + + + + + + + + + + +class IfcDimensionCount_WR1: + SCOPE = "type" + TYPE_NAME = "IfcDimensionCount" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0 < self <= 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFontStyle_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontStyle" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','italic','oblique'] + + + + + +class IfcFontVariant_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontVariant" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps'] + + + + + +class IfcFontWeight_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontWeight" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps','100','200','300','400','500','600','700','800','900'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcHeatingValueMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcHeatingValueMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMonthInYearNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcMonthInYearNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 12 + + + + + + + + + + + + + + +class IfcNonNegativeLengthMeasure_NotNegative: + SCOPE = "type" + TYPE_NAME = "IfcNonNegativeLengthMeasure" + RULE_NAME = "NotNegative" + + @staticmethod + def __call__(self): + + + assert self >= 0. + + + + + +class IfcNormalisedRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcNormalisedRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPHMeasure_WR21: + SCOPE = "type" + TYPE_NAME = "IfcPHMeasure" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 14.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPositiveInteger_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveInteger" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + +class IfcPositiveLengthMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveLengthMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositivePlaneAngleMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositivePlaneAngleMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositiveRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcSpecularRoughness_WR1: + SCOPE = "type" + TYPE_NAME = "IfcSpecularRoughness" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTextAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['left','right','center','justify'] + + + + + +class IfcTextDecoration_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextDecoration" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['none','underline','overline','line-through','blink'] + + + + + + + + + + + + + + +class IfcTextTransformation_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextTransformation" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['capitalize','uppercase','lowercase','none'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcActorRole_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcActorRole" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + role = self.Role + + assert (role != IfcRoleEnum.USERDEFINED) or ((role == IfcRoleEnum.USERDEFINED) and exists(self.UserDefinedRole)) + + + + + +class IfcActuator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcActuator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcactuatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcActuatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + purpose = self.Purpose + + assert (not exists(purpose)) or ((purpose != IfcAddressTypeEnum.USERDEFINED) or ((purpose == IfcAddressTypeEnum.USERDEFINED) and exists(self.UserDefinedPurpose))) + + + + + +class IfcAdvancedBrep_HasAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrep" + RULE_NAME = "HasAdvancedFaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([afs for afs in self.Outer.CfsFaces if not 'ifc4x3_rc4.ifcadvancedface' in typeof(afs)])) == 0 + + + + + +class IfcAdvancedBrepWithVoids_VoidsHaveAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrepWithVoids" + RULE_NAME = "VoidsHaveAdvancedFaces" + + @staticmethod + def __call__(self): + voids = self.Voids + + assert (sizeof([vsh for vsh in voids if (sizeof([afs for afs in vsh.CfsFaces if not 'ifc4x3_rc4.ifcadvancedface' in typeof(afs)])) == 0])) == 0 + + + + + +class IfcAdvancedFace_ApplicableSurface: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableSurface" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc4.ifcelementarysurface','ifc4x3_rc4.ifcsweptsurface','ifc4x3_rc4.ifcbsplinesurface'] * typeof(self.FaceSurface))) == 1 + + + + +class IfcAdvancedFace_RequiresEdgeCurve: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "RequiresEdgeCurve" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x3_rc4.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not 'ifc4x3_rc4.ifcedgecurve' in typeof(oe.EdgeElement)])) == 0])) == 0 + + + + +class IfcAdvancedFace_ApplicableEdgeCurves: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableEdgeCurves" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x3_rc4.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not (sizeof(['ifc4x3_rc4.ifcline','ifc4x3_rc4.ifcconic','ifc4x3_rc4.ifcpolyline','ifc4x3_rc4.ifcbsplinecurve'] * typeof(oe.EdgeElement.EdgeGeometry))) == 1])) == 0])) == 0 + + + + + +class IfcAirTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcairterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminalBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcairterminalboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirToAirHeatRecovery_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirToAirHeatRecovery_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcairtoairheatrecoverytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirToAirHeatRecoveryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecoveryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAlarm_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAlarm_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcalarmtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAlarmType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarmType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcApproval_HasIdentifierOrName: + SCOPE = "entity" + TYPE_NAME = "IfcApproval" + RULE_NAME = "HasIdentifierOrName" + + @staticmethod + def __call__(self): + identifier = self.Identifier + name = self.Name + + assert exists(identifier) or exists(name) + + + + + + + + +class IfcArbitraryClosedProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert outercurve.Dim == 2 + + + + +class IfcArbitraryClosedProfileDef_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x3_rc4.ifcline' in typeof(outercurve) + + + + +class IfcArbitraryClosedProfileDef_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x3_rc4.ifcoffsetcurve2d' in typeof(outercurve) + + + + + +class IfcArbitraryOpenProfileDef_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_rc4.ifccenterlineprofiledef' in typeof(self)) or (self.ProfileType == IfcProfileTypeEnum.CURVE) + + + + +class IfcArbitraryOpenProfileDef_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + curve = self.Curve + + assert curve.Dim == 2 + + + + + +class IfcArbitraryProfileDefWithVoids_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == area + + + + +class IfcArbitraryProfileDefWithVoids_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if temp.Dim != 2])) == 0 + + + + +class IfcArbitraryProfileDefWithVoids_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if 'ifc4x3_rc4.ifcline' in typeof(temp)])) == 0 + + + + + + + + +class IfcAsymmetricIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + bottomflangethickness = self.BottomFlangeThickness + topflangethickness = self.TopFlangeThickness + + assert (not exists(topflangethickness)) or ((bottomflangethickness + topflangethickness) < overalldepth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + + assert (webthickness < bottomflangewidth) and (webthickness < topflangewidth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidBottomFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidBottomFilletRadius" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + bottomflangefilletradius = self.BottomFlangeFilletRadius + + assert (not exists(bottomflangefilletradius)) or (bottomflangefilletradius <= ((bottomflangewidth - webthickness) / 2.)) + + + + +class IfcAsymmetricIShapeProfileDef_ValidTopFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidTopFilletRadius" + + @staticmethod + def __call__(self): + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + topflangefilletradius = self.TopFlangeFilletRadius + + assert (not exists(topflangefilletradius)) or (topflangefilletradius <= ((topflangewidth - webthickness) / 2.)) + + + + + +class IfcAudioVisualAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAudioVisualAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcaudiovisualappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAudioVisualApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAxis1Placement_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis1Placement_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis1Placement_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc4.ifccartesianpoint' in typeof(self.Location) + + + + +def calc_IfcAxis1Placement_Z(self): + axis = self.Axis + return \ + nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + + + + +class IfcAxis2Placement2D_RefDirIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "RefDirIs2D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 2) + + + + +class IfcAxis2Placement2D_LocationIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIs2D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 2 + + + + +class IfcAxis2Placement2D_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc4.ifccartesianpoint' in typeof(self.Location) + + + + +def calc_IfcAxis2Placement2D_P(self): + refdirection = self.RefDirection + return \ + IfcBuild2Axes(refdirection) + + + + +class IfcAxis2Placement3D_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis2Placement3D_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis2Placement3D_RefDirIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "RefDirIs3D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 3) + + + + +class IfcAxis2Placement3D_AxisToRefDirPosition: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisToRefDirPosition" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + +class IfcAxis2Placement3D_AxisAndRefDirProvision: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisAndRefDirProvision" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert not exists(axis) ^ exists(refdirection) + + + + +class IfcAxis2Placement3D_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc4.ifccartesianpoint' in typeof(self.Location) + + + + +def calc_IfcAxis2Placement3D_P(self): + axis = self.Axis + refdirection = self.RefDirection + return \ + IfcBuildAxes(axis,refdirection) + + + + +class IfcAxis2PlacementLinear_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2PlacementLinear" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc4.ifcpointbydistanceexpression' in typeof(self.Location) + + + + +class IfcAxis2PlacementLinear_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2PlacementLinear" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + + +class IfcBSplineCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + controlpointslist = self.ControlPointsList + + assert (sizeof([temp for temp in controlpointslist if temp.Dim != (controlpointslist[1 - 1].Dim)])) == 0 + + + + +def calc_IfcBSplineCurve_UpperIndexOnControlPoints(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineCurve_ControlPoints(self): + controlpointslist = self.ControlPointsList + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + return \ + IfcListToArray(controlpointslist,0,upperindexoncontrolpoints) + + + + +class IfcBSplineCurveWithKnots_ConsistentBSpline: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "ConsistentBSpline" + + @staticmethod + def __call__(self): + degree = self.Degree + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + knotmultiplicities = self.KnotMultiplicities + knots = self.Knots + upperindexonknots = self.UpperIndexOnKnots + + assert IfcConstraintsParamBSpline(degree,upperindexonknots,upperindexoncontrolpoints,knotmultiplicities,knots) + + + + +class IfcBSplineCurveWithKnots_CorrespondingKnotLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "CorrespondingKnotLists" + + @staticmethod + def __call__(self): + knotmultiplicities = self.KnotMultiplicities + upperindexonknots = self.UpperIndexOnKnots + + assert sizeof(knotmultiplicities) == upperindexonknots + + + + +def calc_IfcBSplineCurveWithKnots_UpperIndexOnKnots(self): + knots = self.Knots + return \ + sizeof(knots) + + + + +def calc_IfcBSplineSurface_UUpper(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineSurface_VUpper(self): + controlpointslist = self.ControlPointsList + return \ + (sizeof(controlpointslist[1 - 1])) - 1 + + + +def calc_IfcBSplineSurface_ControlPoints(self): + controlpointslist = self.ControlPointsList + uupper = self.UUpper + vupper = self.VUpper + return \ + IfcMakeArrayOfArray(controlpointslist,0,uupper,0,vupper) + + + + +class IfcBSplineSurfaceWithKnots_UDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "UDirectionConstraints" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + uknots = self.UKnots + knotuupper = self.KnotUUpper + + assert IfcConstraintsParamBSpline(self.UDegree,knotuupper,self.UUpper,umultiplicities,uknots) + + + + +class IfcBSplineSurfaceWithKnots_VDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "VDirectionConstraints" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + vknots = self.VKnots + knotvupper = self.KnotVUpper + + assert IfcConstraintsParamBSpline(self.VDegree,knotvupper,self.VUpper,vmultiplicities,vknots) + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingULists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingULists" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + knotuupper = self.KnotUUpper + + assert sizeof(umultiplicities) == knotuupper + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingVLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingVLists" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + knotvupper = self.KnotVUpper + + assert sizeof(vmultiplicities) == knotvupper + + + + +def calc_IfcBSplineSurfaceWithKnots_KnotVUpper(self): + vknots = self.VKnots + return \ + sizeof(vknots) + + + +def calc_IfcBSplineSurfaceWithKnots_KnotUUpper(self): + uknots = self.UKnots + return \ + sizeof(uknots) + + + + +class IfcBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBeamStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcBeamStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc4.ifcrelassociates.relatedobjects') if ('ifc4x3_rc4.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc4.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBearing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBearing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcbearingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBearingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBlobTexture_SupportedRasterFormat: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "SupportedRasterFormat" + + @staticmethod + def __call__(self): + + + assert self.RasterFormat in ['bmp','jpg','gif','png'] + + + + +class IfcBlobTexture_RasterCodeByteStream: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "RasterCodeByteStream" + + @staticmethod + def __call__(self): + rastercode = self.RasterCode + + assert (blength(rastercode) % 8) == 0 + + + + + + + + +class IfcBoiler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBoiler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcboilertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBoilerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoilerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBooleanClippingResult_FirstOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "FirstOperandType" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert ('ifc4x3_rc4.ifcsweptareasolid' in typeof(firstoperand)) or ('ifc4x3_rc4.ifcsweptdiscsolid' in typeof(firstoperand)) or ('ifc4x3_rc4.ifcbooleanclippingresult' in typeof(firstoperand)) + + + + +class IfcBooleanClippingResult_SecondOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "SecondOperandType" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert 'ifc4x3_rc4.ifchalfspacesolid' in typeof(secondoperand) + + + + +class IfcBooleanClippingResult_OperatorType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "OperatorType" + + @staticmethod + def __call__(self): + operator = self.Operator + + assert operator == difference + + + + + +class IfcBooleanResult_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + secondoperand = self.SecondOperand + + assert firstoperand.Dim == secondoperand.Dim + + + + +class IfcBooleanResult_FirstOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "FirstOperandClosed" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert (not 'ifc4x3_rc4.ifctessellatedfaceset' in typeof(firstoperand)) or (exists(firstoperand.Closed) and firstoperand.Closed) + + + + +class IfcBooleanResult_SecondOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SecondOperandClosed" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert (not 'ifc4x3_rc4.ifctessellatedfaceset' in typeof(secondoperand)) or (exists(secondoperand.Closed) and secondoperand.Closed) + + + + +def calc_IfcBooleanResult_Dim(self): + firstoperand = self.FirstOperand + return \ + firstoperand.Dim + + + + + + + + + + +class IfcBoundaryCurve_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBoundaryCurve" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + + + assert self.ClosedCurve + + + + + + + + + + + + + + + + + + + + + + + +def calc_IfcBoundingBox_Dim(self): + + return \ + 3 + + + + +class IfcBoxedHalfSpace_UnboundedSurface: + SCOPE = "entity" + TYPE_NAME = "IfcBoxedHalfSpace" + RULE_NAME = "UnboundedSurface" + + @staticmethod + def __call__(self): + + + assert not 'ifc4x3_rc4.ifccurveboundedplane' in typeof(self.BaseSurface) + + + + + +class IfcBridge_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBridge" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBridgeTypeEnum.USERDEFINED) or ((predefinedtype == IfcBridgeTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcBuildingElementPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementPart_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcbuildingelementparttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementPartType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPartType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBuildingElementProxy_HasObjectName: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "HasObjectName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcBuildingElementProxy_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementProxy_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcbuildingelementproxytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementProxyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcBuiltElement_MaxOneMaterialAssociation: + SCOPE = "entity" + TYPE_NAME = "IfcBuiltElement" + RULE_NAME = "MaxOneMaterialAssociation" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.HasAssociations if 'ifc4x3_rc4.ifcrelassociatesmaterial' in typeof(temp)])) <= 1 + + + + + + + + +class IfcBuiltSystem_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuiltSystem" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuiltSystemTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuiltSystemTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcBurner_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBurner_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcburnertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBurnerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurnerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCShapeProfileDef_ValidGirth: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidGirth" + + @staticmethod + def __call__(self): + depth = self.Depth + girth = self.Girth + + assert girth < (depth / 2.) + + + + +class IfcCShapeProfileDef_ValidInternalFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidInternalFilletRadius" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + internalfilletradius = self.InternalFilletRadius + + assert (not exists(internalfilletradius)) or ((internalfilletradius <= ((width / 2.) - wallthickness)) and (internalfilletradius <= ((depth / 2.) - wallthickness))) + + + + +class IfcCShapeProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + + assert (wallthickness < (width / 2.)) and (wallthickness < (depth / 2.)) + + + + + +class IfcCableCarrierFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccablecarrierfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableCarrierSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccablecarriersegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccablefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccablesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCaissonFoundation_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCaissonFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccaissonfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCaissonFoundationType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundationType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCartesianPoint_CP2Dor3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianPoint" + RULE_NAME = "CP2Dor3D" + + @staticmethod + def __call__(self): + coordinates = self.Coordinates + + assert hiindex(coordinates) >= 2 + + + + +def calc_IfcCartesianPoint_Dim(self): + coordinates = self.Coordinates + return \ + hiindex(coordinates) + + + + +def calc_IfcCartesianPointList_Dim(self): + + return \ + IfcPointListDim(self) + + + + + + + + + + +class IfcCartesianTransformationOperator_ScaleGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator" + RULE_NAME = "ScaleGreaterZero" + + @staticmethod + def __call__(self): + scl = self.Scl + + assert scl > 0.0 + + + + +def calc_IfcCartesianTransformationOperator_Scl(self): + scale = self.Scale + return \ + nvl(scale,1.0) + + + +def calc_IfcCartesianTransformationOperator_Dim(self): + localorigin = self.LocalOrigin + return \ + localorigin.Dim + + + + +class IfcCartesianTransformationOperator2D_DimEqual2: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "DimEqual2" + + @staticmethod + def __call__(self): + + + assert self.Dim == 2 + + + + +class IfcCartesianTransformationOperator2D_Axis1Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis1Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 2) + + + + +class IfcCartesianTransformationOperator2D_Axis2Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis2Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 2) + + + + +def calc_IfcCartesianTransformationOperator2D_U(self): + + return \ + IfcBaseAxis(2,self.Axis1,self.Axis2,None) + + + + +class IfcCartesianTransformationOperator2DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator2DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + + +class IfcCartesianTransformationOperator3D_DimIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "DimIs3D" + + @staticmethod + def __call__(self): + + + assert self.Dim == 3 + + + + +class IfcCartesianTransformationOperator3D_Axis1Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis1Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis2Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis2Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis3Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis3Is3D" + + @staticmethod + def __call__(self): + axis3 = self.Axis3 + + assert (not exists(axis3)) or (axis3.Dim == 3) + + + + +def calc_IfcCartesianTransformationOperator3D_U(self): + axis3 = self.Axis3 + return \ + IfcBaseAxis(3,self.Axis1,self.Axis2,axis3) + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale3GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale3GreaterZero" + + @staticmethod + def __call__(self): + scl3 = self.Scl3 + + assert scl3 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl3(self): + scale3 = self.Scale3 + return \ + nvl(scale3,self.Scl) + + + + + + + +class IfcChiller_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChiller_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcchillertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChillerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChillerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcChimney_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChimney_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcchimneytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChimneyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimneyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcCircleHollowProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCircleHollowProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert wallthickness < self.Radius + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoil_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccoiltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoilType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoilType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcColumn_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcColumn_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccolumntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcColumnStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcColumnStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc4.ifcrelassociates.relatedobjects') if ('ifc4x3_rc4.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc4.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcColumnType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumnType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcComplexProperty_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert (sizeof([temp for temp in hasproperties if self == temp])) == 0 + + + + +class IfcComplexProperty_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + +class IfcComplexPropertyTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + +class IfcComplexPropertyTemplate_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert (sizeof([temp for temp in haspropertytemplates if self == temp])) == 0 + + + + + +class IfcCompositeCurve_CurveContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "CurveContinuous" + + @staticmethod + def __call__(self): + segments = self.Segments + closedcurve = self.ClosedCurve + + assert ((not closedcurve) and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 1)) or (closedcurve and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 0)) + + + + +class IfcCompositeCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (sizeof([temp for temp in segments if temp.Dim != (segments[1 - 1].Dim)])) == 0 + + + + +def calc_IfcCompositeCurve_NSegments(self): + segments = self.Segments + return \ + sizeof(segments) + + + +def calc_IfcCompositeCurve_ClosedCurve(self): + segments = self.Segments + nsegments = self.NSegments + return \ + (segments[nsegments - 1].Transition) != discontinuous + + + + +class IfcCompositeCurveOnSurface_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveOnSurface" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + + assert sizeof(basissurface) > 0 + + + + +def calc_IfcCompositeCurveOnSurface_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + +class IfcCompositeCurveSegment_ParentIsBoundedCurve: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveSegment" + RULE_NAME = "ParentIsBoundedCurve" + + @staticmethod + def __call__(self): + parentcurve = self.ParentCurve + + assert 'ifc4x3_rc4.ifcboundedcurve' in typeof(parentcurve) + + + + +def calc_IfcCompositeCurveSegment_Dim(self): + parentcurve = self.ParentCurve + return \ + parentcurve.Dim + + + + +class IfcCompositeProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if temp.ProfileType != (profiles[1 - 1].ProfileType)])) == 0 + + + + +class IfcCompositeProfileDef_NoRecursion: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "NoRecursion" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if 'ifc4x3_rc4.ifccompositeprofiledef' in typeof(temp)])) == 0 + + + + + +class IfcCompressor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCompressor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccompressortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCompressorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCondenser_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCondenser_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccondensertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCondenserType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenserType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcConstraint_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcConstraint" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + constraintgrade = self.ConstraintGrade + + assert (constraintgrade != IfcConstraintEnum.USERDEFINED) or ((constraintgrade == IfcConstraintEnum.USERDEFINED) and exists(self.UserDefinedGrade)) + + + + + +class IfcConstructionEquipmentResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionEquipmentResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionMaterialResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionMaterialResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionProductResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionProductResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + + + + + + + + + + + + + +class IfcController_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcController_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccontrollertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcControllerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcControllerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcConveyorSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConveyorSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcConveyorSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcConveyorSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcconveyorsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcConveyorSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConveyorSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcConveyorSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCooledBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCooledBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccooledbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCooledBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCoolingTower_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoolingTower_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccoolingtowertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoolingTowerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTowerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + +class IfcCourse_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCourse" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCourseTypeEnum.USERDEFINED) or ((predefinedtype == IfcCourseTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCourse_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCourse" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccoursetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCourseType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCourseType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCourseTypeEnum.USERDEFINED) or ((predefinedtype == IfcCourseTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCovering_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCovering_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccoveringtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoveringType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoveringType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCrewResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcCrewResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +def calc_IfcCsgPrimitive3D_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcCurtainWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCurtainWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifccurtainwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCurtainWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcCurve_Dim(self): + + return \ + IfcCurveDim(self) + + + + + + + + + + +def calc_IfcCurveSegment_Dim(self): + parentcurve = self.ParentCurve + return \ + parentcurve.Dim + + + + +class IfcCurveStyle_MeasureOfWidth: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "MeasureOfWidth" + + @staticmethod + def __call__(self): + curvewidth = self.CurveWidth + + assert (not exists(curvewidth)) or ('ifc4x3_rc4.ifcpositivelengthmeasure' in typeof(curvewidth)) or (('ifc4x3_rc4.ifcdescriptivemeasure' in typeof(curvewidth)) and (curvewidth == 'bylayer')) + + + + +class IfcCurveStyle_IdentifiableCurveStyle: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "IdentifiableCurveStyle" + + @staticmethod + def __call__(self): + curvefont = self.CurveFont + curvewidth = self.CurveWidth + curvecolour = self.CurveColour + + assert exists(curvefont) or exists(curvewidth) or exists(curvecolour) + + + + + + + + + + + +class IfcCurveStyleFontPattern_VisibleLengthGreaterEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyleFontPattern" + RULE_NAME = "VisibleLengthGreaterEqualZero" + + @staticmethod + def __call__(self): + visiblesegmentlength = self.VisibleSegmentLength + + assert visiblesegmentlength >= 0. + + + + + + + + +class IfcDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDeepFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDeepFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcdeepfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + + + + +class IfcDerivedProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + parentprofile = self.ParentProfile + + assert self.ProfileType == parentprofile.ProfileType + + + + + +class IfcDerivedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof(elements) > 1) or ((sizeof(elements) == 1) and ((elements[1 - 1].Exponent) != 1)) + + + + +class IfcDerivedUnit_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + unittype = self.UnitType + + assert (unittype != IfcDerivedUnitEnum.USERDEFINED) or ((unittype == IfcDerivedUnitEnum.USERDEFINED) and exists(self.UserDefinedType)) + + + + +def calc_IfcDerivedUnit_Dimensions(self): + elements = self.Elements + return \ + IfcDeriveDimensionalExponents(elements) + + + + + + + + + + +class IfcDirection_MagnitudeGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcDirection" + RULE_NAME = "MagnitudeGreaterZero" + + @staticmethod + def __call__(self): + directionratios = self.DirectionRatios + + assert (sizeof([tmp for tmp in directionratios if tmp != 0.0])) > 0 + + + + +def calc_IfcDirection_Dim(self): + directionratios = self.DirectionRatios + return \ + hiindex(directionratios) + + + + +class IfcDirectrixCurveSweptAreaSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcDirectrixCurveSweptAreaSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x3_rc4.ifcconic','ifc4x3_rc4.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + + + + +class IfcDiscreteAccessory_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDiscreteAccessory_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcdiscreteaccessorytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDiscreteAccessoryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessoryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDistributionChamberElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionChamberElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcdistributionchamberelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionChamberElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDistributionSystem_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionSystem" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionSystemEnum.USERDEFINED) or ((predefinedtype == IfcDistributionSystemEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcDocumentReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDocumentReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + name = self.Name + referenceddocument = self.ReferencedDocument + + assert exists(name) ^ exists(referenceddocument) + + + + + +class IfcDoor_CorrectStyleAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectStyleAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcdoortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + +class IfcDoor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDoorTypeEnum.USERDEFINED) or ((predefinedtype == IfcDoorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDoor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcdoortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDoorLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcDoorLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + thresholddepth = self.ThresholdDepth + thresholdthickness = self.ThresholdThickness + + assert not exists(thresholddepth) and (not exists(thresholdthickness)) + + + + +class IfcDoorLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + transomthickness = self.TransomThickness + transomoffset = self.TransomOffset + + assert (exists(transomoffset) and exists(transomthickness)) ^ ((not exists(transomoffset)) and (not exists(transomthickness))) + + + + +class IfcDoorLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + casingthickness = self.CasingThickness + casingdepth = self.CasingDepth + + assert (exists(casingdepth) and exists(casingthickness)) ^ ((not exists(casingdepth)) and (not exists(casingthickness))) + + + + +class IfcDoorLiningProperties_WR35: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR35" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc4.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc4.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcDoorPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc4.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc4.ifcdoorstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + + + + + + + +class IfcDoorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDoorTypeEnum.USERDEFINED) or ((predefinedtype == IfcDoorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDraughtingPreDefinedColour_PreDefinedColourNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedColour" + RULE_NAME = "PreDefinedColourNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['black','red','green','blue','yellow','magenta','cyan','white','bylayer'] + + + + + +class IfcDraughtingPreDefinedCurveFont_PreDefinedCurveFontNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedCurveFont" + RULE_NAME = "PreDefinedCurveFontNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['continuous','chain','chaindoubledash','dashed','dotted','bylayer'] + + + + + +class IfcDuctFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcductfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcductsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSilencer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSilencer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcductsilencertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSilencerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEarthworksCut_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEarthworksCut" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEarthworksCutTypeEnum.USERDEFINED) or ((predefinedtype == IfcEarthworksCutTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcEarthworksFill_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEarthworksFill" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEarthworksFillTypeEnum.USERDEFINED) or ((predefinedtype == IfcEarthworksFillTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcEdgeLoop_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + edgelist = self.EdgeList + ne = self.Ne + + assert (edgelist[1 - 1].EdgeStart) == (edgelist[ne - 1].EdgeEnd) + + + + +class IfcEdgeLoop_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcLoopHeadToTail(self) + + + + +def calc_IfcEdgeLoop_Ne(self): + edgelist = self.EdgeList + return \ + sizeof(edgelist) + + + + +class IfcElectricAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcelectricappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcelectricdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowStorageDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowStorageDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcelectricflowstoragedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowStorageDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowTreatmentDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowTreatmentDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcelectricflowtreatmentdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowTreatmentDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricGenerator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricGenerator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcelectricgeneratortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricGeneratorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGeneratorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricMotor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricMotor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcelectricmotortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricMotorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricTimeControl_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricTimeControl_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcelectrictimecontroltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricTimeControlType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControlType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcElementAssembly_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElementAssembly_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcelementassemblytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElementAssemblyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssemblyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcElementQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcElementQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + quantities = self.Quantities + + assert IfcUniqueQuantityNames(quantities) + + + + + + + + + + + + + + + + + + + + + + + +class IfcEngine_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEngine_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcenginetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEngineType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngineType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporativeCooler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporativeCooler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcevaporativecoolertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporativeCoolerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCoolerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcevaporatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvent_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvent_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (not exists(eventtriggertype)) or (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + +class IfcEventType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + +class IfcEventType_CorrectEventTriggerType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectEventTriggerType" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + + + + +class IfcExternalReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcExternalReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + location = self.Location + identification = self.Identification + name = self.Name + + assert exists(identification) or exists(location) or exists(name) + + + + + + + + + + + + + + + + + + + + + + + +class IfcExtrudedAreaSolid_ValidExtrusionDirection: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolid" + RULE_NAME = "ValidExtrusionDirection" + + @staticmethod + def __call__(self): + + + assert IfcDotProduct(IfcDirection(DirectionRatios=[0.0,0.0,1.0]),self.ExtrudedDirection) != 0.0 + + + + + +class IfcExtrudedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + +class IfcFace_HasOuterBound: + SCOPE = "entity" + TYPE_NAME = "IfcFace" + RULE_NAME = "HasOuterBound" + + @staticmethod + def __call__(self): + bounds = self.Bounds + + assert (sizeof([temp for temp in bounds if 'ifc4x3_rc4.ifcfaceouterbound' in typeof(temp)])) <= 1 + + + + + +def calc_IfcFaceBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + + + + + + + + + + + + + + + + + + + +class IfcFacilityPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFacilityPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert ((predefinedtype != IfcBridgePartTypeEnum.USERDEFINED) or (predefinedtype != IfcRailwayPartTypeEnum.USERDEFINED) or (predefinedtype != IfcRoadPartTypeEnum.USERDEFINED) or (predefinedtype != IfcMarinePartTypeEnum.USERDEFINED) or (predefinedtype != IfcFacilityPartCommonTypeEnum.USERDEFINED)) or (((predefinedtype == IfcBridgePartTypeEnum.USERDEFINED) or (predefinedtype == IfcRailwayPartTypeEnum.USERDEFINED) or (predefinedtype == IfcRoadPartTypeEnum.USERDEFINED) or (predefinedtype == IfcMarinePartTypeEnum.USERDEFINED) or (predefinedtype == IfcFacilityPartCommonTypeEnum.USERDEFINED)) and exists(self.ObjectType)) + + + + + + + + +class IfcFan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFan_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcfantype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFanType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFanType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFeatureElement_NotContained: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElement" + RULE_NAME = "NotContained" + + @staticmethod + def __call__(self): + containedinstructure = self.ContainedInStructure + + assert sizeof(containedinstructure) == 0 + + + + + + + + +class IfcFeatureElementSubtraction_HasNoSubtraction: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "HasNoSubtraction" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasOpenings) == 0 + + + + +class IfcFeatureElementSubtraction_IsNotFilling: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "IsNotFilling" + + @staticmethod + def __call__(self): + + + assert sizeof(self.FillsVoids) == 0 + + + + + +class IfcFillAreaStyle_MaxOneColour: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneColour" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x3_rc4.ifccolour' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_MaxOneExtHatchStyle: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneExtHatchStyle" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x3_rc4.ifcexternallydefinedhatchstyle' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_ConsistentHatchStyleDef: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "ConsistentHatchStyleDef" + + @staticmethod + def __call__(self): + + + assert IfcCorrectFillAreaStyle(self.FillStyles) + + + + + +class IfcFillAreaStyleHatching_PatternStart2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "PatternStart2D" + + @staticmethod + def __call__(self): + patternstart = self.PatternStart + + assert (not exists(patternstart)) or (patternstart.Dim == 2) + + + + +class IfcFillAreaStyleHatching_RefHatchLine2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "RefHatchLine2D" + + @staticmethod + def __call__(self): + pointofreferencehatchline = self.PointOfReferenceHatchLine + + assert (not exists(pointofreferencehatchline)) or (pointofreferencehatchline.Dim == 2) + + + + + + + + +class IfcFilter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFilter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcfiltertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFilterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFireSuppressionTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFireSuppressionTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcfiresuppressionterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFireSuppressionTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + +class IfcFlowInstrument_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowInstrument_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcflowinstrumenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowInstrumentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrumentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFlowMeter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowMeter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcflowmetertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowMeterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFooting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFooting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcfootingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFootingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFootingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcFurniture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFurniture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcfurnituretype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFurnitureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurnitureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeographicElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcGeographicElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcgeographicelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcGeographicElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeometricCurveSet_NoSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricCurveSet" + RULE_NAME = "NoSurfaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Elements if 'ifc4x3_rc4.ifcsurface' in typeof(temp)])) == 0 + + + + + +class IfcGeometricRepresentationContext_North2D: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationContext" + RULE_NAME = "North2D" + + @staticmethod + def __call__(self): + truenorth = self.TrueNorth + + assert (not exists(truenorth)) or (hiindex(truenorth.DirectionRatios) == 2) + + + + + + + + +class IfcGeometricRepresentationSubContext_ParentNoSub: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "ParentNoSub" + + @staticmethod + def __call__(self): + parentcontext = self.ParentContext + + assert not 'ifc4x3_rc4.ifcgeometricrepresentationsubcontext' in typeof(parentcontext) + + + + +class IfcGeometricRepresentationSubContext_UserTargetProvided: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "UserTargetProvided" + + @staticmethod + def __call__(self): + targetview = self.TargetView + userdefinedtargetview = self.UserDefinedTargetView + + assert (targetview != IfcGeometricProjectionEnum.USERDEFINED) or ((targetview == IfcGeometricProjectionEnum.USERDEFINED) and exists(userdefinedtargetview)) + + + + +class IfcGeometricRepresentationSubContext_NoCoordOperation: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "NoCoordOperation" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasCoordinateOperation) == 0 + + + + +def calc_IfcGeometricRepresentationSubContext_WorldCoordinateSystem(self): + parentcontext = self.ParentContext + return \ + parentcontext.WorldCoordinateSystem + + + +def calc_IfcGeometricRepresentationSubContext_CoordinateSpaceDimension(self): + parentcontext = self.ParentContext + return \ + parentcontext.CoordinateSpaceDimension + + + +def calc_IfcGeometricRepresentationSubContext_TrueNorth(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.TrueNorth,IfcConvertDirectionInto2D(self.WorldCoordinateSystem.P[2 - 1])) + + + +def calc_IfcGeometricRepresentationSubContext_Precision(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.Precision,1) + + + + +class IfcGeometricSet_ConsistentDim: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricSet" + RULE_NAME = "ConsistentDim" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof([temp for temp in elements if temp.Dim != (elements[1 - 1].Dim)])) == 0 + + + + +def calc_IfcGeometricSet_Dim(self): + elements = self.Elements + return \ + elements[1 - 1].Dim + + + + + + + + + + + + + + + + + + + +def calc_IfcGradientCurve_RelativeElevation(self): + + return \ + IfcGradient(self) + + + + + + + +class IfcGridAxis_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + axiscurve = self.AxisCurve + + assert axiscurve.Dim == 2 + + + + +class IfcGridAxis_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + partofw = self.PartOfW + partofv = self.PartOfV + partofu = self.PartOfU + + assert (sizeof(partofu) == 1) ^ (sizeof(partofv) == 1) ^ (sizeof(partofw) == 1) + + + + + + + + + + + +def calc_IfcHalfSpaceSolid_Dim(self): + + return \ + 3 + + + + +class IfcHeatExchanger_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHeatExchanger_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcheatexchangertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHeatExchangerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchangerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcHumidifier_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHumidifier_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifchumidifiertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHumidifierType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifierType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + flangethickness = self.FlangeThickness + + assert (2. * flangethickness) < overalldepth + + + + +class IfcIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + webthickness = self.WebThickness + + assert webthickness < overallwidth + + + + +class IfcIShapeProfileDef_ValidFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFilletRadius" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + overalldepth = self.OverallDepth + webthickness = self.WebThickness + flangethickness = self.FlangeThickness + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or ((filletradius <= ((overallwidth - webthickness) / 2.)) and (filletradius <= ((overalldepth - (2. * flangethickness)) / 2.))) + + + + + + + + +class IfcImpactProtectionDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or ((predefinedtype != IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED)) or (((predefinedtype == IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or (predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) or (predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED)) and exists(self.ObjectType)) + + + + +class IfcImpactProtectionDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcimpactprotectiondevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcImpactProtectionDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert ((predefinedtype != IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED)) or (((predefinedtype == IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or (predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) or (predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED)) and exists(self.ObjectType)) + + + + + + + + +class IfcIndexedPolyCurve_Consecutive: + SCOPE = "entity" + TYPE_NAME = "IfcIndexedPolyCurve" + RULE_NAME = "Consecutive" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (not exists(segments)) or IfcConsecutiveSegments(segments) + + + + + + + + + + + + + + + + + +class IfcInterceptor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcInterceptor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcinterceptortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcInterceptorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIntersectionCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + +class IfcIntersectionCurve_DistinctSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "DistinctSurfaces" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) != (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + + + + + + + + + + + +class IfcJunctionBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcJunctionBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcjunctionboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcJunctionBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcLShapeProfileDef_ValidThickness: + SCOPE = "entity" + TYPE_NAME = "IfcLShapeProfileDef" + RULE_NAME = "ValidThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + thickness = self.Thickness + + assert (thickness < depth) and ((not exists(width)) or (thickness < width)) + + + + + +class IfcLaborResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcLaborResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +class IfcLamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifclamptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcLightFixture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLightFixture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifclightfixturetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLightFixtureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixtureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcLine_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcLine" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + pnt = self.Pnt + dir = self.Dir + + assert dir.Dim == pnt.Dim + + + + + + + + + + + + + + +class IfcLiquidTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLiquidTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcLiquidTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLiquidTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcliquidterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLiquidTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLiquidTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcLiquidTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcLocalPlacement_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcLocalPlacement" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + placementrelto = self.PlacementRelTo + relativeplacement = self.RelativePlacement + + assert IfcCorrectLocalPlacement(relativeplacement,placementrelto) + + + + + + + + + + + + + + + + + +class IfcMarineFacility_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMarineFacility" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMarineFacilityTypeEnum.USERDEFINED) or ((predefinedtype == IfcMarineFacilityTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + + + + + + + + + + +class IfcMaterialDefinitionRepresentation_OnlyStyledRepresentations: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialDefinitionRepresentation" + RULE_NAME = "OnlyStyledRepresentations" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x3_rc4.ifcstyledrepresentation' in typeof(temp)])) == 0 + + + + + +class IfcMaterialLayer_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialLayer" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + +def calc_IfcMaterialLayerSet_TotalThickness(self): + + return \ + IfcMlsTotalThickness(self) + + + + + + + + + + + + + +class IfcMaterialProfile_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialProfile" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMechanicalFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMechanicalFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcmechanicalfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMechanicalFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMedicalDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMedicalDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcmedicaldevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMedicalDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMember_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMember_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcmembertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMemberStandardCase_HasMaterialProfileSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcMemberStandardCase" + RULE_NAME = "HasMaterialProfileSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc4.ifcrelassociates.relatedobjects') if ('ifc4x3_rc4.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc4.ifcmaterialprofilesetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcMemberType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMemberType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcMirroredProfileDef_Operator(self): + + return \ + IfcCartesianTransformationOperator2D(Axis1=IfcDirection(DirectionRatios=[-1.,0.]), Axis2=IfcDirection(DirectionRatios=[0.,1.]), LocalOrigin=IfcCartesianPoint(Coordinates=[0.,0.]), Scale=1.) + + + + +class IfcMobileTelecommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMobileTelecommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcmobiletelecommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMobileTelecommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcMooringDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMooringDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMooringDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMooringDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcmooringdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMooringDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMooringDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMooringDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMotorConnection_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMotorConnection_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcmotorconnectiontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMotorConnectionType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnectionType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcNamedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcNamedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert IfcCorrectDimensions(self.UnitType,self.Dimensions) + + + + + +class IfcNavigationElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcNavigationElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcNavigationElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcNavigationElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcnavigationelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcNavigationElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcNavigationElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcNavigationElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + isdefinedby = self.IsDefinedBy + + assert (sizeof(isdefinedby) == 0) or IfcUniqueDefinitionNames(isdefinedby) + + + + + + + + + + + +class IfcObjective_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcObjective" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + objectivequalifier = self.ObjectiveQualifier + + assert (objectivequalifier != IfcObjectiveEnum.USERDEFINED) or ((objectivequalifier == IfcObjectiveEnum.USERDEFINED) and exists(self.UserDefinedQualifier)) + + + + + +class IfcOccupant_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcOccupant" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not predefinedtype == IfcOccupantTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcOffsetCurve2D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve2D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 2 + + + + + +class IfcOffsetCurve3D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve3D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 3 + + + + + + + + +class IfcOpenCrossProfileDef_CorrectProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrectProfileType" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == IfcProfileTypeEnum.CURVE + + + + +class IfcOpenCrossProfileDef_CorrespondingSlopeWidths: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrespondingSlopeWidths" + + @staticmethod + def __call__(self): + widths = self.Widths + slopes = self.Slopes + + assert sizeof(slopes) == sizeof(widths) + + + + +class IfcOpenCrossProfileDef_CorrespondingTags: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrespondingTags" + + @staticmethod + def __call__(self): + slopes = self.Slopes + tags = self.Tags + + assert (not exists(tags)) or (sizeof(tags) == (sizeof(slopes) + 1)) + + + + + + + + +class IfcOpeningElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOpeningElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcOpeningElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcOpeningElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + + + + +class IfcOrientedEdge_EdgeElementNotOriented: + SCOPE = "entity" + TYPE_NAME = "IfcOrientedEdge" + RULE_NAME = "EdgeElementNotOriented" + + @staticmethod + def __call__(self): + edgeelement = self.EdgeElement + + assert not 'ifc4x3_rc4.ifcorientededge' in typeof(edgeelement) + + + + +def calc_IfcOrientedEdge_EdgeStart(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeStart,edgeelement.EdgeEnd) + + + +def calc_IfcOrientedEdge_EdgeEnd(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeEnd,edgeelement.EdgeStart) + + + + + + + +class IfcOutlet_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcOutlet_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcoutlettype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcOutletType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutletType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcOwnerHistory_CorrectChangeAction: + SCOPE = "entity" + TYPE_NAME = "IfcOwnerHistory" + RULE_NAME = "CorrectChangeAction" + + @staticmethod + def __call__(self): + changeaction = self.ChangeAction + lastmodifieddate = self.LastModifiedDate + + assert exists(lastmodifieddate) or ((not exists(lastmodifieddate)) and (not exists(changeaction))) or ((not exists(lastmodifieddate)) and exists(changeaction) and ((changeaction == IfcChangeActionEnum.NOTDEFINED) or (changeaction == IfcChangeActionEnum.NOCHANGE))) + + + + + + + + +class IfcPath_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcPath" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcPathHeadToTail(self) + + + + + +class IfcPavement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPavement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPavementTypeEnum.USERDEFINED) or ((predefinedtype == IfcPavementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPavement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPavement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcpavementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPavementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPavementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPavementTypeEnum.USERDEFINED) or ((predefinedtype == IfcPavementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPcurve_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcPcurve" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + referencecurve = self.ReferenceCurve + + assert referencecurve.Dim == 2 + + + + + + + + + + + + + + +class IfcPerson_IdentifiablePerson: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "IdentifiablePerson" + + @staticmethod + def __call__(self): + identification = self.Identification + familyname = self.FamilyName + givenname = self.GivenName + + assert exists(identification) or exists(familyname) or exists(givenname) + + + + +class IfcPerson_ValidSetOfNames: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "ValidSetOfNames" + + @staticmethod + def __call__(self): + familyname = self.FamilyName + givenname = self.GivenName + middlenames = self.MiddleNames + + assert (not exists(middlenames)) or exists(familyname) or exists(givenname) + + + + + + + + +class IfcPhysicalComplexQuantity_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert (sizeof([temp for temp in hasquantities if self == temp])) == 0 + + + + +class IfcPhysicalComplexQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert IfcUniqueQuantityNames(hasquantities) + + + + + + + + + + + +class IfcPile_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPile_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcpiletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPileType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPileType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcpipefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcpipesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPixelTexture_MinPixelInS: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInS" + + @staticmethod + def __call__(self): + width = self.Width + + assert width >= 1 + + + + +class IfcPixelTexture_MinPixelInT: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInT" + + @staticmethod + def __call__(self): + height = self.Height + + assert height >= 1 + + + + +class IfcPixelTexture_NumberOfColours: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "NumberOfColours" + + @staticmethod + def __call__(self): + colourcomponents = self.ColourComponents + + assert 1 <= colourcomponents <= 4 + + + + +class IfcPixelTexture_SizeOfPixelList: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "SizeOfPixelList" + + @staticmethod + def __call__(self): + width = self.Width + height = self.Height + pixel = self.Pixel + + assert sizeof(pixel) == (width * height) + + + + +class IfcPixelTexture_PixelAsByteAndSameLength: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "PixelAsByteAndSameLength" + + @staticmethod + def __call__(self): + pixel = self.Pixel + + assert (sizeof([temp for temp in pixel if ((blength(temp) % 8) == 0) and (blength(temp) == (blength(pixel[1 - 1])))])) == sizeof(pixel) + + + + + +def calc_IfcPlacement_Dim(self): + location = self.Location + return \ + location.Dim + + + + + + + + + + + + + + + + +class IfcPlate_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPlate_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcplatetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPlateStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcPlateStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc4.ifcrelassociates.relatedobjects') if ('ifc4x3_rc4.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc4.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcPlateType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlateType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcPointByDistanceExpression_Dim(self): + basiscurve = self.BasisCurve + return \ + basiscurve.Dim + + + + +def calc_IfcPointOnCurve_Dim(self): + basiscurve = self.BasisCurve + return \ + basiscurve.Dim + + + + +def calc_IfcPointOnSurface_Dim(self): + basissurface = self.BasisSurface + return \ + basissurface.Dim + + + + +class IfcPolyLoop_AllPointsSameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyLoop" + RULE_NAME = "AllPointsSameDim" + + @staticmethod + def __call__(self): + polygon = self.Polygon + + assert (sizeof([temp for temp in polygon if temp.Dim != (polygon[1 - 1].Dim)])) == 0 + + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryDim" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert polygonalboundary.Dim == 2 + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryType: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryType" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert (sizeof(typeof(polygonalboundary) * ['ifc4x3_rc4.ifcpolyline','ifc4x3_rc4.ifccompositecurve'])) == 1 + + + + + + + + +class IfcPolyline_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyline" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + points = self.Points + + assert (sizeof([temp for temp in points if temp.Dim != (points[1 - 1].Dim)])) == 0 + + + + + +class IfcPolynomialCurve_ValidCoefficients: + SCOPE = "entity" + TYPE_NAME = "IfcPolynomialCurve" + RULE_NAME = "ValidCoefficients" + + @staticmethod + def __call__(self): + coefficientsx = self.CoefficientsX + coefficientsy = self.CoefficientsY + coefficientsz = self.CoefficientsZ + + assert (exists(coefficientsx) and exists(coefficientsy)) or (exists(coefficientsx) and exists(coefficientsz)) or (exists(coefficientsy) and exists(coefficientsz)) or (exists(coefficientsx) and exists(coefficientsy) and exists(coefficientsz)) + + + + +class IfcPolynomialCurve_CorrectPositionDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolynomialCurve" + RULE_NAME = "CorrectPositionDim" + + @staticmethod + def __call__(self): + position = self.Position + coefficientsz = self.CoefficientsZ + + assert ((position.Dim == 2) and (not exists(coefficientsz))) or (position.Dim == 3) + + + + + + + + +class IfcPositioningElement_HasPlacement: + SCOPE = "entity" + TYPE_NAME = "IfcPositioningElement" + RULE_NAME = "HasPlacement" + + @staticmethod + def __call__(self): + + + assert exists(self.ObjectPlacement) + + + + + +class IfcPostalAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPostalAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + internallocation = self.InternalLocation + addresslines = self.AddressLines + postalbox = self.PostalBox + town = self.Town + region = self.Region + postalcode = self.PostalCode + country = self.Country + + assert exists(internallocation) or exists(addresslines) or exists(postalbox) or exists(postalcode) or exists(town) or exists(region) or exists(country) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPresentationLayerAssignment_ApplicableItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerAssignment" + RULE_NAME = "ApplicableItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x3_rc4.ifcshaperepresentation','ifc4x3_rc4.ifcgeometricrepresentationitem','ifc4x3_rc4.ifcmappeditem'])) == 1])) == sizeof(assigneditems) + + + + + +class IfcPresentationLayerWithStyle_ApplicableOnlyToItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerWithStyle" + RULE_NAME = "ApplicableOnlyToItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x3_rc4.ifcgeometricrepresentationitem','ifc4x3_rc4.ifcmappeditem'])) >= 1])) == sizeof(assigneditems) + + + + + + + + +class IfcProcedure_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProcedure_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcProcedureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + + + + +class IfcProduct_PlacementForShapeRepresentation: + SCOPE = "entity" + TYPE_NAME = "IfcProduct" + RULE_NAME = "PlacementForShapeRepresentation" + + @staticmethod + def __call__(self): + objectplacement = self.ObjectPlacement + representation = self.Representation + + assert (exists(representation) and exists(objectplacement)) or (exists(representation) and ((sizeof([temp for temp in representation.Representations if 'ifc4x3_rc4.ifcshaperepresentation' in typeof(temp)])) == 0)) or (not exists(representation)) + + + + + +class IfcProductDefinitionShape_OnlyShapeModel: + SCOPE = "entity" + TYPE_NAME = "IfcProductDefinitionShape" + RULE_NAME = "OnlyShapeModel" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x3_rc4.ifcshapemodel' in typeof(temp)])) == 0 + + + + + + + + + + + + + + +class IfcProject_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProject_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert (not exists(self.RepresentationContexts)) or ((sizeof([temp for temp in self.RepresentationContexts if 'ifc4x3_rc4.ifcgeometricrepresentationsubcontext' in typeof(temp)])) == 0) + + + + +class IfcProject_NoDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "NoDecomposition" + + @staticmethod + def __call__(self): + + + assert sizeof(self.Decomposes) == 0 + + + + + + + + + + + +class IfcProjectedCRS_IsLengthUnit: + SCOPE = "entity" + TYPE_NAME = "IfcProjectedCRS" + RULE_NAME = "IsLengthUnit" + + @staticmethod + def __call__(self): + mapunit = self.MapUnit + + assert (not exists(mapunit)) or (mapunit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + + +class IfcProjectionElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProjectionElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProjectionElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcProjectionElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcPropertyBoundedValue_SameUnitUpperLower: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperLower" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + lowerboundvalue = self.LowerBoundValue + + assert (not exists(upperboundvalue)) or (not exists(lowerboundvalue)) or (typeof(upperboundvalue) == typeof(lowerboundvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitUpperSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperSet" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(upperboundvalue)) or (not exists(setpointvalue)) or (typeof(upperboundvalue) == typeof(setpointvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitLowerSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitLowerSet" + + @staticmethod + def __call__(self): + lowerboundvalue = self.LowerBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(lowerboundvalue)) or (not exists(setpointvalue)) or (typeof(lowerboundvalue) == typeof(setpointvalue)) + + + + + + + + +class IfcPropertyDependencyRelationship_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyDependencyRelationship" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + dependingproperty = self.DependingProperty + dependantproperty = self.DependantProperty + + assert dependingproperty != dependantproperty + + + + + +class IfcPropertyEnumeratedValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeratedValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + enumerationvalues = self.EnumerationValues + enumerationreference = self.EnumerationReference + + assert (not exists(enumerationreference)) or (not exists(enumerationvalues)) or ((sizeof([temp for temp in enumerationvalues if temp in enumerationreference.EnumerationValues])) == sizeof(enumerationvalues)) + + + + + +class IfcPropertyEnumeration_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeration" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.EnumerationValues if not (typeof(self.EnumerationValues[1 - 1])) == typeof(temp)])) == 0 + + + + + +class IfcPropertyListValue_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyListValue" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.ListValues if not (typeof(self.ListValues[1 - 1])) == typeof(temp)])) == 0 + + + + + + + + +class IfcPropertySet_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySet_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + + + + +class IfcPropertySetTemplate_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySetTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + + + + + +class IfcPropertyTableValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + definedvalues = self.DefinedValues + + assert ((not exists(definingvalues)) and (not exists(definedvalues))) or (sizeof(definingvalues) == sizeof(definedvalues)) + + + + +class IfcPropertyTableValue_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + + assert (not exists(definingvalues)) or ((sizeof([temp for temp in self.DefiningValues if typeof(temp) != (typeof(self.DefiningValues[1 - 1]))])) == 0) + + + + +class IfcPropertyTableValue_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + definedvalues = self.DefinedValues + + assert (not exists(definedvalues)) or ((sizeof([temp for temp in self.DefinedValues if typeof(temp) != (typeof(self.DefinedValues[1 - 1]))])) == 0) + + + + + + + + + + + +class IfcProtectiveDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcprotectivedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcprotectivedevicetrippingunittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProtectiveDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProxy_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcProxy" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcPump_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPump_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcpumptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPumpType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPumpType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcQuantityArea_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.AREAUNIT) + + + + +class IfcQuantityArea_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + areavalue = self.AreaValue + + assert areavalue >= 0. + + + + + +class IfcQuantityCount_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityCount" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + countvalue = self.CountValue + + assert countvalue >= 0. + + + + + +class IfcQuantityLength_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + +class IfcQuantityLength_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + lengthvalue = self.LengthValue + + assert lengthvalue >= 0. + + + + + + + + +class IfcQuantityTime_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.TIMEUNIT) + + + + +class IfcQuantityTime_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + timevalue = self.TimeValue + + assert timevalue >= 0. + + + + + +class IfcQuantityVolume_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.VOLUMEUNIT) + + + + +class IfcQuantityVolume_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + volumevalue = self.VolumeValue + + assert volumevalue >= 0. + + + + + +class IfcQuantityWeight_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.MASSUNIT) + + + + +class IfcQuantityWeight_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + weightvalue = self.WeightValue + + assert weightvalue >= 0. + + + + + +class IfcRail_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRail" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRail_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRail" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcrailtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRailing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRailing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcrailingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRailway_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcRailway" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailwayTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcRamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcramptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRampFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcrampflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRationalBSplineCurveWithKnots_SameNumOfWeightsAndPoints: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "SameNumOfWeightsAndPoints" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert sizeof(weightsdata) == sizeof(self.ControlPointsList) + + + + +class IfcRationalBSplineCurveWithKnots_WeightsGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "WeightsGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcCurveWeightsPositive(self) + + + + +def calc_IfcRationalBSplineCurveWithKnots_Weights(self): + weightsdata = self.WeightsData + return \ + IfcListToArray(weightsdata,0,self.UpperIndexOnControlPoints) + + + + +class IfcRationalBSplineSurfaceWithKnots_CorrespondingWeightsDataLists: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingWeightsDataLists" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert (sizeof(weightsdata) == sizeof(self.ControlPointsList)) and ((sizeof(weightsdata[1 - 1])) == (sizeof(self.ControlPointsList[1 - 1]))) + + + + +class IfcRationalBSplineSurfaceWithKnots_WeightValuesGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "WeightValuesGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcSurfaceWeightsPositive(self) + + + + +def calc_IfcRationalBSplineSurfaceWithKnots_Weights(self): + uupper = self.UUpper + vupper = self.VUpper + weightsdata = self.WeightsData + return \ + IfcMakeArrayOfArray(weightsdata,0,uupper,0,vupper) + + + + +class IfcRectangleHollowProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert (wallthickness < (self.XDim / 2.)) and (wallthickness < (self.YDim / 2.)) + + + + +class IfcRectangleHollowProfileDef_ValidInnerRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidInnerRadius" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + innerfilletradius = self.InnerFilletRadius + + assert (not exists(innerfilletradius)) or ((innerfilletradius <= ((self.XDim / 2.) - wallthickness)) and (innerfilletradius <= ((self.YDim / 2.) - wallthickness))) + + + + +class IfcRectangleHollowProfileDef_ValidOuterRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidOuterRadius" + + @staticmethod + def __call__(self): + outerfilletradius = self.OuterFilletRadius + + assert (not exists(outerfilletradius)) or ((outerfilletradius <= (self.XDim / 2.)) and (outerfilletradius <= (self.YDim / 2.))) + + + + + + + + + + + +class IfcRectangularTrimmedSurface_U1AndU2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "U1AndU2Different" + + @staticmethod + def __call__(self): + u1 = self.U1 + u2 = self.U2 + + assert u1 != u2 + + + + +class IfcRectangularTrimmedSurface_V1AndV2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "V1AndV2Different" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + + assert v1 != v2 + + + + +class IfcRectangularTrimmedSurface_UsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "UsenseCompatible" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + u1 = self.U1 + u2 = self.U2 + usense = self.Usense + + assert (('ifc4x3_rc4.ifcelementarysurface' in typeof(basissurface)) and (not 'ifc4x3_rc4.ifcplane' in typeof(basissurface))) or ('ifc4x3_rc4.ifcsurfaceofrevolution' in typeof(basissurface)) or (usense == (u2 > u1)) + + + + +class IfcRectangularTrimmedSurface_VsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "VsenseCompatible" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + vsense = self.Vsense + + assert vsense == (v2 > v1) + + + + + + + + + + + + + + + + + +class IfcReinforcedSoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcedSoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcedSoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcedSoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcReinforcingBar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingBar_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcreinforcingbartype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingBarType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + +class IfcReinforcingBarType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + + + + + + + + +class IfcReinforcingMesh_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingMesh_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcreinforcingmeshtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingMeshType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + +class IfcReinforcingMeshType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + + + + + +class IfcRelAggregates_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAggregates" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelAssigns_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssigns" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + relatedobjects = self.RelatedObjects + relatedobjectstype = self.RelatedObjectsType + + assert IfcCorrectObjectAssignment(relatedobjectstype,relatedobjects) + + + + + +class IfcRelAssignsToActor_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToActor" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingactor = self.RelatingActor + + assert (sizeof([temp for temp in self.RelatedObjects if relatingactor == temp])) == 0 + + + + + +class IfcRelAssignsToControl_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToControl" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontrol = self.RelatingControl + + assert (sizeof([temp for temp in self.RelatedObjects if relatingcontrol == temp])) == 0 + + + + + +class IfcRelAssignsToGroup_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToGroup" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatinggroup = self.RelatingGroup + + assert (sizeof([temp for temp in self.RelatedObjects if relatinggroup == temp])) == 0 + + + + + + + + +class IfcRelAssignsToProcess_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProcess" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + + assert (sizeof([temp for temp in self.RelatedObjects if relatingprocess == temp])) == 0 + + + + + +class IfcRelAssignsToProduct_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProduct" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingproduct = self.RelatingProduct + + assert (sizeof([temp for temp in self.RelatedObjects if relatingproduct == temp])) == 0 + + + + + +class IfcRelAssignsToResource_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToResource" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingresource = self.RelatingResource + + assert (sizeof([temp for temp in self.RelatedObjects if relatingresource == temp])) == 0 + + + + + + + + + + + + + + + + + + + + + + + +class IfcRelAssociatesMaterial_NoVoidElement: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "NoVoidElement" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if ('ifc4x3_rc4.ifcfeatureelementsubtraction' in typeof(temp)) or ('ifc4x3_rc4.ifcvirtualelement' in typeof(temp))])) == 0 + + + + +class IfcRelAssociatesMaterial_AllowedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "AllowedElements" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if (sizeof(typeof(temp) * ['ifc4x3_rc4.ifcelement','ifc4x3_rc4.ifcelementtype','ifc4x3_rc4.ifcwindowstyle','ifc4x3_rc4.ifcdoorstyle','ifc4x3_rc4.ifcstructuralmember','ifc4x3_rc4.ifcport'])) == 0])) == 0 + + + + + + + + + + + +class IfcRelConnectsElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelConnectsPathElements_NormalizedRelatingPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatingPriorities" + + @staticmethod + def __call__(self): + relatingpriorities = self.RelatingPriorities + + assert (sizeof(relatingpriorities) == 0) or ((sizeof([temp for temp in relatingpriorities if 0 <= temp <= 100])) == sizeof(relatingpriorities)) + + + + +class IfcRelConnectsPathElements_NormalizedRelatedPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatedPriorities" + + @staticmethod + def __call__(self): + relatedpriorities = self.RelatedPriorities + + assert (sizeof(relatedpriorities) == 0) or ((sizeof([temp for temp in relatedpriorities if 0 <= temp <= 100])) == sizeof(relatedpriorities)) + + + + + + + + +class IfcRelConnectsPorts_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPorts" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingport = self.RelatingPort + relatedport = self.RelatedPort + + assert relatingport != relatedport + + + + + + + + + + + + + + + + + +class IfcRelContainedInSpatialStructure_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRelContainedInSpatialStructure" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if 'ifc4x3_rc4.ifcspatialstructureelement' in typeof(temp)])) == 0 + + + + + + + + + + + +class IfcRelDeclares_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelDeclares" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontext = self.RelatingContext + relateddefinitions = self.RelatedDefinitions + + assert (sizeof([temp for temp in relateddefinitions if relatingcontext == temp])) == 0 + + + + + + + + + + + + + + +class IfcRelDefinesByProperties_NoRelatedTypeObject: + SCOPE = "entity" + TYPE_NAME = "IfcRelDefinesByProperties" + RULE_NAME = "NoRelatedTypeObject" + + @staticmethod + def __call__(self): + + + assert (sizeof([types for types in self.RelatedObjects if 'ifc4x3_rc4.ifctypeobject' in typeof(types)])) == 0 + + + + + + + + + + + + + + + + + +class IfcRelInterferesElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelInterferesElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelNests_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelNests" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelPositions_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelPositions" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingpositioningelement = self.RelatingPositioningElement + relatedproducts = self.RelatedProducts + + assert (sizeof([temp for temp in relatedproducts if relatingpositioningelement == temp])) == 0 + + + + + + + + +class IfcRelReferencedInSpatialStructure_AllowedRelatedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelReferencedInSpatialStructure" + RULE_NAME = "AllowedRelatedElements" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if ('ifc4x3_rc4.ifcspatialstructureelement' in typeof(temp)) and (not 'ifc4x3_rc4.ifcspace' in typeof(temp))])) == 0 + + + + + +class IfcRelSequence_AvoidInconsistentSequence: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "AvoidInconsistentSequence" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + relatedprocess = self.RelatedProcess + + assert relatingprocess != relatedprocess + + + + +class IfcRelSequence_CorrectSequenceType: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "CorrectSequenceType" + + @staticmethod + def __call__(self): + sequencetype = self.SequenceType + userdefinedsequencetype = self.UserDefinedSequenceType + + assert (sequencetype != IfcSequenceEnum.USERDEFINED) or ((sequencetype == IfcSequenceEnum.USERDEFINED) and exists(userdefinedsequencetype)) + + + + + + + + +class IfcRelSpaceBoundary_CorrectPhysOrVirt: + SCOPE = "entity" + TYPE_NAME = "IfcRelSpaceBoundary" + RULE_NAME = "CorrectPhysOrVirt" + + @staticmethod + def __call__(self): + relatedbuildingelement = self.RelatedBuildingElement + physicalorvirtualboundary = self.PhysicalOrVirtualBoundary + + assert ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Physical) and (not 'ifc4x3_rc4.ifcvirtualelement' in typeof(relatedbuildingelement))) or ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Virtual) and (('ifc4x3_rc4.ifcvirtualelement' in typeof(relatedbuildingelement)) or ('ifc4x3_rc4.ifcopeningelement' in typeof(relatedbuildingelement)))) or (physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.NotDefined) + + + + + + + + + + + + + + + + + +class IfcReparametrisedCompositeCurveSegment_PositiveLengthParameter: + SCOPE = "entity" + TYPE_NAME = "IfcReparametrisedCompositeCurveSegment" + RULE_NAME = "PositiveLengthParameter" + + @staticmethod + def __call__(self): + paramlength = self.ParamLength + + assert paramlength > 0.0 + + + + + + + + + + + + + + +class IfcRepresentationMap_ApplicableMappedRepr: + SCOPE = "entity" + TYPE_NAME = "IfcRepresentationMap" + RULE_NAME = "ApplicableMappedRepr" + + @staticmethod + def __call__(self): + mappedrepresentation = self.MappedRepresentation + + assert 'ifc4x3_rc4.ifcshapemodel' in typeof(mappedrepresentation) + + + + + + + + + + + + + + + + + + + + +class IfcRevolvedAreaSolid_AxisStartInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisStartInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Location.Coordinates[3 - 1]) == 0.0 + + + + +class IfcRevolvedAreaSolid_AxisDirectionInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisDirectionInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Z.DirectionRatios[3 - 1]) == 0.0 + + + + +def calc_IfcRevolvedAreaSolid_AxisLine(self): + axis = self.Axis + return \ + IfcLine(Pnt=axis.Location, Dir=IfcVector(Orientation=axis.Z, Magnitude=1.0)) + + + + +class IfcRevolvedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + + + + + + + +class IfcRoad_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcRoad" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoadTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcRoof_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRoof_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcrooftype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRoofType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoofType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcRoundedRectangleProfileDef_ValidRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRoundedRectangleProfileDef" + RULE_NAME = "ValidRadius" + + @staticmethod + def __call__(self): + roundingradius = self.RoundingRadius + + assert (roundingradius <= (self.XDim / 2.)) and (roundingradius <= (self.YDim / 2.)) + + + + + +def calc_IfcSIUnit_Dimensions(self): + + return \ + IfcDimensionsForSiUnit(self.Name) + + + + +class IfcSanitaryTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSanitaryTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcsanitaryterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSanitaryTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSeamCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + +class IfcSeamCurve_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) == (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + + + + + + + + + + + +class IfcSectionedSolid_DirectrixIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "DirectrixIs3D" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSectionedSolid_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSolid_SectionsSameType: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "SectionsSameType" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (typeof(crosssections[1 - 1])) != typeof(temp)])) == 0 + + + + + +class IfcSectionedSolidHorizontal_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSolidHorizontal_NoLongitudinalOffsets: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "NoLongitudinalOffsets" + + @staticmethod + def __call__(self): + crosssectionpositions = self.CrossSectionPositions + + assert (sizeof([temp for temp in crosssectionpositions if exists(temp.Location.OffsetLongitudinal)])) == 0 + + + + + +class IfcSectionedSpine_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSpine_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSpine_SpineCurveDim: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "SpineCurveDim" + + @staticmethod + def __call__(self): + spinecurve = self.SpineCurve + + assert spinecurve.Dim == 3 + + + + +def calc_IfcSectionedSpine_Dim(self): + + return \ + 3 + + + + + + + + + + + + + +class IfcSensor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSensor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcsensortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSensorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcShadingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcShadingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcshadingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcShadingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcShapeModel_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcShapeModel" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + ofshapeaspect = self.OfShapeAspect + + assert (sizeof(self.OfProductRepresentation) == 1) ^ (sizeof(self.RepresentationMap) == 1) ^ (sizeof(ofshapeaspect) == 1) + + + + + +class IfcShapeRepresentation_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_rc4.ifcgeometricrepresentationcontext' in typeof(self.ContextOfItems) + + + + +class IfcShapeRepresentation_NoTopologicalItem: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "NoTopologicalItem" + + @staticmethod + def __call__(self): + items = self.Items + + assert (sizeof([temp for temp in items if ('ifc4x3_rc4.ifctopologicalrepresentationitem' in typeof(temp)) and (not (sizeof(['ifc4x3_rc4.ifcvertexpoint','ifc4x3_rc4.ifcedgecurve','ifc4x3_rc4.ifcfacesurface'] * typeof(temp))) == 1)])) == 0 + + + + +class IfcShapeRepresentation_HasRepresentationType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationType" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcShapeRepresentation_HasRepresentationIdentifier: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationIdentifier" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationIdentifier) + + + + +class IfcShapeRepresentation_CorrectItemsForType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectItemsForType" + + @staticmethod + def __call__(self): + + + assert IfcShapeRepresentationTypes(self.RepresentationType,self.Items) + + + + + +def calc_IfcShellBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + +class IfcSign_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSign" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSignTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSign_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSign" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcsigntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSignType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSignTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSignal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSignalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSignal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSignal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcsignaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSignalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSignalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + +class IfcSlab_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSlab_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcslabtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSlabElementedCase_HasDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcSlabElementedCase" + RULE_NAME = "HasDecomposition" + + @staticmethod + def __call__(self): + + + assert hiindex(self.IsDecomposedBy) > 0 + + + + + +class IfcSlabStandardCase_HasMaterialLayerSetusage: + SCOPE = "entity" + TYPE_NAME = "IfcSlabStandardCase" + RULE_NAME = "HasMaterialLayerSetusage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc4.ifcrelassociates.relatedobjects') if ('ifc4x3_rc4.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc4.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcSlabType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlabType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSolarDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSolarDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcsolardevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSolarDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcSolidModel_Dim(self): + + return \ + 3 + + + + + + + +class IfcSpace_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpace_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcspacetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeater_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpaceHeater_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcspaceheatertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeaterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeaterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSpaceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcSpatialStructureElement_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialStructureElement" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + + + assert (hiindex(self.Decomposes) == 1) and ('ifc4x3_rc4.ifcrelaggregates' in (typeof(self.Decomposes[1 - 1]))) and (('ifc4x3_rc4.ifcproject' in (typeof(self.Decomposes[1 - 1].RelatingObject))) or ('ifc4x3_rc4.ifcspatialstructureelement' in (typeof(self.Decomposes[1 - 1].RelatingObject)))) + + + + + + + + +class IfcSpatialZone_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpatialZone_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcspatialzonetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpatialZoneType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZoneType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcStackTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStackTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcstackterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStackTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStair_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStair_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcstairtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStairFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcstairflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStairType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcStructuralAnalysisModel_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralAnalysisModel" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAnalysisModelTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralAnalysisModel_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralAnalysisModel" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAnalysisModelTypeEnum.USERDEFINED) or ((predefinedtype == IfcAnalysisModelTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcStructuralCurveAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralCurveAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveAction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert predefinedtype != IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + + + + + + + +class IfcStructuralCurveMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralCurveReaction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveReaction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.SINUS) and (predefinedtype != IfcStructuralCurveActivityTypeEnum.PARABOLA) + + + + + + + + +class IfcStructuralLinearAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc4.ifcstructuralloadlinearforce','ifc4x3_rc4.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + +class IfcStructuralLinearAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralCurveActivityTypeEnum.CONST + + + + + + + + +class IfcStructuralLoadCase_IsLoadCasePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadCase" + RULE_NAME = "IsLoadCasePredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcLoadGroupTypeEnum.LOAD_CASE + + + + + +class IfcStructuralLoadConfiguration_ValidListSize: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadConfiguration" + RULE_NAME = "ValidListSize" + + @staticmethod + def __call__(self): + values = self.Values + locations = self.Locations + + assert (not exists(locations)) or (sizeof(locations) == sizeof(values)) + + + + + +class IfcStructuralLoadGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + actiontype = self.ActionType + actionsource = self.ActionSource + + assert ((predefinedtype != IfcLoadGroupTypeEnum.USERDEFINED) and (actiontype != IfcActionTypeEnum.USERDEFINED) and (actionsource != IfcActionSourceTypeEnum.USERDEFINED)) or exists(self.ObjectType) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcStructuralPlanarAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc4.ifcstructuralloadplanarforce','ifc4x3_rc4.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + +class IfcStructuralPlanarAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralSurfaceActivityTypeEnum.CONST + + + + + +class IfcStructuralPointAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc4.ifcstructuralloadsingleforce','ifc4x3_rc4.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralPointReaction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointReaction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_rc4.ifcstructuralloadsingleforce','ifc4x3_rc4.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralResultGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralResultGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + theorytype = self.TheoryType + + assert (theorytype != IfcAnalysisTheoryTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcStructuralSurfaceAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralSurfaceAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceReaction_HasPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceReaction" + RULE_NAME = "HasPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStyledItem_ApplicableItem: + SCOPE = "entity" + TYPE_NAME = "IfcStyledItem" + RULE_NAME = "ApplicableItem" + + @staticmethod + def __call__(self): + item = self.Item + + assert not 'ifc4x3_rc4.ifcstyleditem' in typeof(item) + + + + + +class IfcStyledRepresentation_OnlyStyledItems: + SCOPE = "entity" + TYPE_NAME = "IfcStyledRepresentation" + RULE_NAME = "OnlyStyledItems" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x3_rc4.ifcstyleditem' in typeof(temp)])) == 0 + + + + + +class IfcSubContractResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcSubContractResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +def calc_IfcSurface_Dim(self): + + return \ + 3 + + + + +class IfcSurfaceCurve_CurveIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIs3D" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert curve3d.Dim == 3 + + + + +class IfcSurfaceCurve_CurveIsNotPcurve: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIsNotPcurve" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert not 'ifc4x3_rc4.ifcpcurve' in typeof(curve3d) + + + + +def calc_IfcSurfaceCurve_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + + + + +class IfcSurfaceFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSurfaceFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcSurfaceOfLinearExtrusion_DepthGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceOfLinearExtrusion" + RULE_NAME = "DepthGreaterZero" + + @staticmethod + def __call__(self): + depth = self.Depth + + assert depth > 0. + + + + +def calc_IfcSurfaceOfLinearExtrusion_ExtrusionAxis(self): + extrudeddirection = self.ExtrudedDirection + depth = self.Depth + return \ + IfcVector(Orientation=extrudeddirection, Magnitude=depth) + + + + +def calc_IfcSurfaceOfRevolution_AxisLine(self): + axisposition = self.AxisPosition + return \ + IfcLine(Pnt=axisposition.Location, Dir=IfcVector(Orientation=axisposition.Z, Magnitude=1.0)) + + + + +class IfcSurfaceReinforcementArea_SurfaceAndOrShearAreaSpecified: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "SurfaceAndOrShearAreaSpecified" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + surfacereinforcement2 = self.SurfaceReinforcement2 + shearreinforcement = self.ShearReinforcement + + assert exists(surfacereinforcement1) or exists(surfacereinforcement2) or exists(shearreinforcement) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea1: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea1" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + + assert (not exists(surfacereinforcement1)) or (((surfacereinforcement1[1 - 1]) >= 0.) and ((surfacereinforcement1[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement1) == 1) or ((surfacereinforcement1[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea2: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea2" + + @staticmethod + def __call__(self): + surfacereinforcement2 = self.SurfaceReinforcement2 + + assert (not exists(surfacereinforcement2)) or (((surfacereinforcement2[1 - 1]) >= 0.) and ((surfacereinforcement2[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement2) == 1) or ((surfacereinforcement2[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea3: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea3" + + @staticmethod + def __call__(self): + shearreinforcement = self.ShearReinforcement + + assert (not exists(shearreinforcement)) or (shearreinforcement >= 0.) + + + + + +class IfcSurfaceStyle_MaxOneShading: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneShading" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc4.ifcsurfacestyleshading' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneLighting: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneLighting" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc4.ifcsurfacestylelighting' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneRefraction: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneRefraction" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc4.ifcsurfacestylerefraction' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneTextures: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneTextures" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc4.ifcsurfacestylewithtextures' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneExtDefined: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneExtDefined" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_rc4.ifcexternallydefinedsurfacestyle' in typeof(style)])) <= 1 + + + + + + + + + + + + + + + + + + + + + + + +class IfcSweptAreaSolid_SweptAreaType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptAreaSolid" + RULE_NAME = "SweptAreaType" + + @staticmethod + def __call__(self): + sweptarea = self.SweptArea + + assert sweptarea.ProfileType == IfcProfileTypeEnum.Area + + + + + +class IfcSweptDiskSolid_DirectrixDim: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixDim" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSweptDiskSolid_InnerRadiusSize: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "InnerRadiusSize" + + @staticmethod + def __call__(self): + radius = self.Radius + innerradius = self.InnerRadius + + assert (not exists(innerradius)) or (radius > innerradius) + + + + +class IfcSweptDiskSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x3_rc4.ifcconic','ifc4x3_rc4.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + +class IfcSweptDiskSolidPolygonal_CorrectRadii: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "CorrectRadii" + + @staticmethod + def __call__(self): + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or (filletradius >= self.Radius) + + + + +class IfcSweptDiskSolidPolygonal_DirectrixIsPolyline: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "DirectrixIsPolyline" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_rc4.ifcpolyline' in typeof(self.Directrix)) or (('ifc4x3_rc4.ifcindexedpolycurve' in typeof(self.Directrix)) and (not exists(self.Directrix.Segments))) + + + + + +class IfcSweptSurface_SweptCurveType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptSurface" + RULE_NAME = "SweptCurveType" + + @staticmethod + def __call__(self): + sweptcurve = self.SweptCurve + + assert sweptcurve.ProfileType == IfcProfileTypeEnum.Curve + + + + + +class IfcSwitchingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSwitchingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcswitchingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSwitchingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSystemFurnitureElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSystemFurnitureElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcsystemfurnitureelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSystemFurnitureElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < depth + + + + +class IfcTShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcTable_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + rows = self.Rows + + assert (sizeof([temp for temp in rows if hiindex(temp.RowCells) != (hiindex(rows[1 - 1].RowCells))])) == 0 + + + + +class IfcTable_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + numberofheadings = self.NumberOfHeadings + + assert 0 <= numberofheadings <= 1 + + + + +def calc_IfcTable_NumberOfCellsInRow(self): + rows = self.Rows + return \ + hiindex(rows[1 - 1].RowCells) + + + +def calc_IfcTable_NumberOfHeadings(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if temp.IsHeading]) + + + +def calc_IfcTable_NumberOfDataRows(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if not temp.IsHeading]) + + + + + + + + + + +class IfcTank_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTank_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifctanktype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTankType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTankType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTask_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTask_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcTaskType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTaskType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + +class IfcTelecomAddress_MinimumDataProvided: + SCOPE = "entity" + TYPE_NAME = "IfcTelecomAddress" + RULE_NAME = "MinimumDataProvided" + + @staticmethod + def __call__(self): + telephonenumbers = self.TelephoneNumbers + facsimilenumbers = self.FacsimileNumbers + pagernumber = self.PagerNumber + electronicmailaddresses = self.ElectronicMailAddresses + wwwhomepageurl = self.WWWHomePageURL + messagingids = self.MessagingIDs + + assert exists(telephonenumbers) or exists(facsimilenumbers) or exists(pagernumber) or exists(electronicmailaddresses) or exists(wwwhomepageurl) or exists(messagingids) + + + + + +class IfcTendon_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendon_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifctendontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonAnchor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifctendonanchortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonConduit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonConduit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifctendonconduittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonConduitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcTessellatedFaceSet_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcTextLiteralWithExtent_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcTextLiteralWithExtent" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + extent = self.Extent + + assert not 'ifc4x3_rc4.ifcplanarbox' in typeof(extent) + + + + + + + + +class IfcTextStyleFontModel_MeasureOfFontSize: + SCOPE = "entity" + TYPE_NAME = "IfcTextStyleFontModel" + RULE_NAME = "MeasureOfFontSize" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_rc4.ifclengthmeasure' in typeof(self.FontSize)) and (self.FontSize > 0.) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTopologyRepresentation_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x3_rc4.ifctopologicalrepresentationitem' in typeof(temp)])) == 0 + + + + +class IfcTopologyRepresentation_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcTopologyRepresentation_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + + + assert IfcTopologyRepresentationTypes(self.RepresentationType,self.Items) + + + + + +class IfcToroidalSurface_MajorLargerMinor: + SCOPE = "entity" + TYPE_NAME = "IfcToroidalSurface" + RULE_NAME = "MajorLargerMinor" + + @staticmethod + def __call__(self): + majorradius = self.MajorRadius + minorradius = self.MinorRadius + + assert minorradius < majorradius + + + + + +class IfcTrackElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTrackElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTrackElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTrackElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifctrackelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTrackElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTrackElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTrackElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTransformer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransformer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifctranformertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransformerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTransportElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or ((predefinedtype != IfcTransportElementFixedTypeEnum.USERDEFINED) and (predefinedtype != IfcTransportElementNonFixedTypeEnum.USERDEFINED)) or (((predefinedtype == IfcTransportElementFixedTypeEnum.USERDEFINED) or (predefinedtype == IfcTransportElementNonFixedTypeEnum.USERDEFINED)) and exists(self.ElementType)) + + + + +class IfcTransportElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifctransportelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransportElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert ((predefinedtype != IfcTransportElementFixedTypeEnum.USERDEFINED) and (predefinedtype != IfcTransportElementNonFixedTypeEnum.USERDEFINED)) or ((predefinedtype == IfcTransportElementFixedTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransportElementNonFixedTypeEnum.USERDEFINED) and exists(self.ElementType))) + + + + + + + + +def calc_IfcTriangulatedFaceSet_NumberOfTriangles(self): + coordindex = self.CoordIndex + return \ + sizeof(coordindex) + + + + +class IfcTriangulatedIrregularNetwork_NotClosed: + SCOPE = "entity" + TYPE_NAME = "IfcTriangulatedIrregularNetwork" + RULE_NAME = "NotClosed" + + @staticmethod + def __call__(self): + + + assert self.Closed == False + + + + + +class IfcTrimmedCurve_Trim1ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim1ValuesConsistent" + + @staticmethod + def __call__(self): + trim1 = self.Trim1 + + assert (hiindex(trim1) == 1) or ((typeof(trim1[1 - 1])) != (typeof(trim1[2 - 1]))) + + + + +class IfcTrimmedCurve_Trim2ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim2ValuesConsistent" + + @staticmethod + def __call__(self): + trim2 = self.Trim2 + + assert (hiindex(trim2) == 1) or ((typeof(trim2[1 - 1])) != (typeof(trim2[2 - 1]))) + + + + +class IfcTrimmedCurve_NoTrimOfBoundedCurves: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "NoTrimOfBoundedCurves" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert not 'ifc4x3_rc4.ifcboundedcurve' in typeof(basiscurve) + + + + + +class IfcTubeBundle_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTubeBundle_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifctubebundletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTubeBundleType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundleType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTypeObject_NameRequired: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "NameRequired" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTypeObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + haspropertysets = self.HasPropertySets + + assert (not exists(haspropertysets)) or IfcUniquePropertySetNames(haspropertysets) + + + + + + + + +class IfcTypeProduct_ApplicableOccurrence: + SCOPE = "entity" + TYPE_NAME = "IfcTypeProduct" + RULE_NAME = "ApplicableOccurrence" + + @staticmethod + def __call__(self): + + + assert (not exists(lambda: self.Types[1 - 1])) or ((sizeof([temp for temp in self.Types[1 - 1].RelatedObjects if not 'ifc4x3_rc4.ifcproduct' in typeof(temp)])) == 0) + + + + + + + + +class IfcUShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + +class IfcUShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcUnitAssignment_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcUnitAssignment" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + units = self.Units + + assert IfcCorrectUnitAssignment(units) + + + + + +class IfcUnitaryControlElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryControlElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcunitarycontrolelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryControlElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcUnitaryEquipment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryEquipment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcunitaryequipmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryEquipmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcValve_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcValve_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcvalvetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcValveType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValveType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVector_MagGreaterOrEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcVector" + RULE_NAME = "MagGreaterOrEqualZero" + + @staticmethod + def __call__(self): + magnitude = self.Magnitude + + assert magnitude >= 0.0 + + + + +def calc_IfcVector_Dim(self): + orientation = self.Orientation + return \ + orientation.Dim + + + + + + + + + + + + + +class IfcVibrationDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcvibrationdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVibrationIsolator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationIsolator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcvibrationisolatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationIsolatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcVoidingFeature_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcVoidingFeature" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVoidingFeatureTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWallElementedCase_HasDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcWallElementedCase" + RULE_NAME = "HasDecomposition" + + @staticmethod + def __call__(self): + + + assert hiindex(self.IsDecomposedBy) > 0 + + + + + +class IfcWallStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcWallStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_rc4.ifcrelassociates.relatedobjects') if ('ifc4x3_rc4.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_rc4.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWasteTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWasteTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcwasteterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWasteTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcWindow_CorrectStyleAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectStyleAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcwindowtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + +class IfcWindow_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWindowTypeEnum.USERDEFINED) or ((predefinedtype == IfcWindowTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWindow_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_rc4.ifcwindowtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWindowLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcWindowLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + firsttransomoffset = self.FirstTransomOffset + secondtransomoffset = self.SecondTransomOffset + + assert not (not exists(firsttransomoffset)) and exists(secondtransomoffset) + + + + +class IfcWindowLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + firstmullionoffset = self.FirstMullionOffset + secondmullionoffset = self.SecondMullionOffset + + assert not (not exists(firstmullionoffset)) and exists(secondmullionoffset) + + + + +class IfcWindowLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc4.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc4.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + +class IfcWindowPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and (('ifc4x3_rc4.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) or ('ifc4x3_rc4.ifcwindowstyle' in (typeof(self.DefinesType[1 - 1])))) + + + + + + + + + + + +class IfcWindowType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWindowTypeEnum.USERDEFINED) or ((predefinedtype == IfcWindowTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWorkCalendar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkCalendar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkCalendarTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkCalendarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcWorkPlan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkPlan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkPlanTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkPlanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcWorkSchedule_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkSchedule" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkScheduleTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkScheduleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcZShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcZShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + + +class IfcZone_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcZone" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof(self.IsGroupedBy) == 0) or ((sizeof([temp for temp in self.IsGroupedBy[1 - 1].RelatedObjects if not ('ifc4x3_rc4.ifczone' in typeof(temp)) or ('ifc4x3_rc4.ifcspace' in typeof(temp)) or ('ifc4x3_rc4.ifcspatialzone' in typeof(temp))])) == 0) + + + + + +class IfcRepresentationContextSameWCS: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcGeometricRepresentationContext = file.by_type("IfcGeometricRepresentationContext") + isdifferent = False + if sizeof(IfcGeometricRepresentationContext) > 1: + for i in range(2, hiindex(IfcGeometricRepresentationContext) + 1): + if (IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem) != (IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem): + isdifferent = (not IfcSameValidPrecision(IfcGeometricRepresentationContext[1 - 1].Precision,IfcGeometricRepresentationContext[i - 1].Precision)) or (not IfcSameAxis2Placement(IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[1 - 1].Precision)) + if isdifferent == True: + break + + assert isdifferent == False + + + + + +class IfcSingleProjectInstance: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcProject = file.by_type("IfcProject") + + + + assert sizeof(IfcProject) <= 1 + + + + +def IfcAssociatedSurface(arg): + + surf = arg.BasisSurface + return surf + + +def IfcBaseAxis(dim, axis1, axis2, axis3): + + + + if dim == 3: + d1 = nvl(IfcNormalise(axis3),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,axis1) + u = [d2,IfcSecondProjAxis(d1,d2,axis2),d1] + else: + if exists(axis1): + d1 = IfcNormalise(axis1) + u = [d1,IfcOrthogonalComplement(d1)] + if exists(axis2): + factor = IfcDotProduct(axis2,u[2 - 1]) + if factor < 0.0: + u[2 - 1].DirectionRatios[1 - 1] = -u[2 - 1].DirectionRatios[1 - 1] + u[2 - 1].DirectionRatios[2 - 1] = -u[2 - 1].DirectionRatios[2 - 1] + else: + if exists(axis2): + d1 = IfcNormalise(axis2) + u = [IfcOrthogonalComplement(d1),d1] + u[1 - 1].DirectionRatios[1 - 1] = -u[1 - 1].DirectionRatios[1 - 1] + u[1 - 1].DirectionRatios[2 - 1] = -u[1 - 1].DirectionRatios[2 - 1] + else: + u = [IfcDirection(DirectionRatios=[1.0,0.0]),IfcDirection(DirectionRatios=[0.0,1.0])] + return u + + +def IfcBooleanChoose(b, choice1, choice2): + + if b: + return choice1 + else: + return choice2 + + +def IfcBuild2Axes(refdirection): + d = nvl(IfcNormalise(refdirection),IfcDirection(DirectionRatios=[1.0,0.0])) + return [d,IfcOrthogonalComplement(d)] + + +def IfcBuildAxes(axis, refdirection): + + d1 = nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,refdirection) + return [d2,IfcNormalise(IfcCrossProduct(d1,d2)).Orientation,d1] + + +def IfcConsecutiveSegments(segments): + result = True + for i in range(1, hiindex(segments) - 1 + 1): + if (segments[i - 1][hiindex(segments[i - 1]) - 1]) != (segments[i - 1][1 - 1]): + result = False + break + return result + + +def IfcConstraintsParamBSpline(degree, upknots, upcp, knotmult, knots): + result = True + + sum = knotmult[1 - 1] + for i in range(2, upknots + 1): + sum = sum + (knotmult[i - 1]) + if (degree < 1) or (upknots < 2) or (upcp < degree) or (sum != (degree + upcp + 2)): + result = False + return result + k = knotmult[1 - 1] + if (k < 1) or (k > (degree + 1)): + result = False + return result + for i in range(2, upknots + 1): + if ((knotmult[i - 1]) < 1) or ((knots[i - 1]) <= (knots[i - 1])): + result = False + return result + k = knotmult[i - 1] + if (i < upknots) and (k > degree): + result = False + return result + if (i == upknots) and (k > (degree + 1)): + result = False + return result + return result + + +def IfcConvertDirectionInto2D(direction): + direction2d = IfcDirection(DirectionRatios=[0.,1.]) + temp = list(direction2d.DirectionRatios) + temp[1 - 1] = direction.DirectionRatios[1 - 1] + direction2d.DirectionRatios = temp + temp = list(direction2d.DirectionRatios) + temp[2 - 1] = direction.DirectionRatios[2 - 1] + direction2d.DirectionRatios = temp + return direction2d + + +def IfcCorrectDimensions(m, dim): + + if m == lengthunit: + if dim == IfcDimensionalExponents(1,0,0,0,0,0,0): + return True + else: + return False + elif m == massunit: + if dim == IfcDimensionalExponents(0,1,0,0,0,0,0): + return True + else: + return False + elif m == timeunit: + if dim == IfcDimensionalExponents(0,0,1,0,0,0,0): + return True + else: + return False + elif m == electriccurrentunit: + if dim == IfcDimensionalExponents(0,0,0,1,0,0,0): + return True + else: + return False + elif m == thermodynamictemperatureunit: + if dim == IfcDimensionalExponents(0,0,0,0,1,0,0): + return True + else: + return False + elif m == amountofsubstanceunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,1,0): + return True + else: + return False + elif m == luminousintensityunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == planeangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == solidangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == areaunit: + if dim == IfcDimensionalExponents(2,0,0,0,0,0,0): + return True + else: + return False + elif m == volumeunit: + if dim == IfcDimensionalExponents(3,0,0,0,0,0,0): + return True + else: + return False + elif m == absorbeddoseunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == radioactivityunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == electriccapacitanceunit: + if dim == IfcDimensionalExponents(-2,-1,4,2,0,0,0): + return True + else: + return False + elif m == doseequivalentunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == electricchargeunit: + if dim == IfcDimensionalExponents(0,0,1,1,0,0,0): + return True + else: + return False + elif m == electricconductanceunit: + if dim == IfcDimensionalExponents(-2,-1,3,2,0,0,0): + return True + else: + return False + elif m == electricvoltageunit: + if dim == IfcDimensionalExponents(2,1,-3,-1,0,0,0): + return True + else: + return False + elif m == electricresistanceunit: + if dim == IfcDimensionalExponents(2,1,-3,-2,0,0,0): + return True + else: + return False + elif m == energyunit: + if dim == IfcDimensionalExponents(2,1,-2,0,0,0,0): + return True + else: + return False + elif m == forceunit: + if dim == IfcDimensionalExponents(1,1,-2,0,0,0,0): + return True + else: + return False + elif m == frequencyunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == inductanceunit: + if dim == IfcDimensionalExponents(2,1,-2,-2,0,0,0): + return True + else: + return False + elif m == illuminanceunit: + if dim == IfcDimensionalExponents(-2,0,0,0,0,0,1): + return True + else: + return False + elif m == luminousfluxunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == magneticfluxunit: + if dim == IfcDimensionalExponents(2,1,-2,-1,0,0,0): + return True + else: + return False + elif m == magneticfluxdensityunit: + if dim == IfcDimensionalExponents(0,1,-2,-1,0,0,0): + return True + else: + return False + elif m == powerunit: + if dim == IfcDimensionalExponents(2,1,-3,0,0,0,0): + return True + else: + return False + elif m == pressureunit: + if dim == IfcDimensionalExponents(-1,1,-2,0,0,0,0): + return True + else: + return False + else: + return unknown + + +def IfcCorrectFillAreaStyle(styles): + hatching = 0 + tiles = 0 + colour = 0 + external = 0 + external = sizeof([style for style in styles if 'ifc4x3_rc4.ifcexternallydefinedhatchstyle' in typeof(style)]) + hatching = sizeof([style for style in styles if 'ifc4x3_rc4.ifcfillareastylehatching' in typeof(style)]) + tiles = sizeof([style for style in styles if 'ifc4x3_rc4.ifcfillareastyletiles' in typeof(style)]) + colour = sizeof([style for style in styles if 'ifc4x3_rc4.ifccolour' in typeof(style)]) + if external > 1: + return False + if (external == 1) and ((hatching > 0) or (tiles > 0) or (colour > 0)): + return False + if colour > 1: + return False + if (hatching > 0) and (tiles > 0): + return False + return True + + +def IfcCorrectLocalPlacement(axisplacement, relplacement): + + if exists(relplacement): + if 'ifc4x3_rc4.ifcgridplacement' in typeof(relplacement): + return None + if 'ifc4x3_rc4.ifclocalplacement' in typeof(relplacement): + if 'ifc4x3_rc4.ifcaxis2placement2d' in typeof(axisplacement): + return True + if 'ifc4x3_rc4.ifcaxis2placement3d' in typeof(axisplacement): + if relplacement.RelativePlacement.Dim == 3: + return True + else: + return False + return True + return None + + +def IfcCorrectObjectAssignment(constraint, objects): + count = 0 + if not exists(constraint): + return True + if constraint == IfcObjectTypeEnum.NOTDEFINED: + return True + elif constraint == IfcObjectTypeEnum.PRODUCT: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc4.ifcproduct' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROCESS: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc4.ifcprocess' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.CONTROL: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc4.ifccontrol' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.RESOURCE: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc4.ifcresource' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.ACTOR: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc4.ifcactor' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.GROUP: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc4.ifcgroup' in typeof(temp)]) + return count == 0 + elif constraint == IfcObjectTypeEnum.PROJECT: + count = sizeof([temp for temp in objects if not 'ifc4x3_rc4.ifcproject' in typeof(temp)]) + return count == 0 + else: + return None + + +def IfcCorrectUnitAssignment(units): + namedunitnumber = 0 + derivedunitnumber = 0 + monetaryunitnumber = 0 + namedunitnames = express_set([]) + derivedunitnames = express_set([]) + namedunitnumber = sizeof([temp for temp in units if ('ifc4x3_rc4.ifcnamedunit' in typeof(temp)) and (not temp.UnitType == IfcUnitEnum.USERDEFINED)]) + derivedunitnumber = sizeof([temp for temp in units if ('ifc4x3_rc4.ifcderivedunit' in typeof(temp)) and (not temp.UnitType == IfcDerivedUnitEnum.USERDEFINED)]) + monetaryunitnumber = sizeof([temp for temp in units if 'ifc4x3_rc4.ifcmonetaryunit' in typeof(temp)]) + for i in range(1, sizeof(units) + 1): + if ('ifc4x3_rc4.ifcnamedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcUnitEnum.USERDEFINED): + namedunitnames = namedunitnames + (units[i - 1].UnitType) + if ('ifc4x3_rc4.ifcderivedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcDerivedUnitEnum.USERDEFINED): + derivedunitnames = derivedunitnames + (units[i - 1].UnitType) + return (sizeof(namedunitnames) == namedunitnumber) and (sizeof(derivedunitnames) == derivedunitnumber) and (monetaryunitnumber <= 1) + + +def IfcCrossProduct(arg1, arg2): + + + + + if ((not exists(arg1)) or (arg1.Dim == 2)) or ((not exists(arg2)) or (arg2.Dim == 2)): + return None + else: + v1 = IfcNormalise(arg1).DirectionRatios + v2 = IfcNormalise(arg2).DirectionRatios + res = IfcDirection(DirectionRatios=[((v1[2 - 1]) * (v2[3 - 1])) - ((v1[3 - 1]) * (v2[2 - 1])),((v1[3 - 1]) * (v2[1 - 1])) - ((v1[1 - 1]) * (v2[3 - 1])),((v1[1 - 1]) * (v2[2 - 1])) - ((v1[2 - 1]) * (v2[1 - 1]))]) + mag = 0.0 + for i in range(1, 3 + 1): + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=arg1, Magnitude=0.0) + return result + + +def IfcCurveDim(curve): + + if 'ifc4x3_rc4.ifcline' in typeof(curve): + return curve.Pnt.Dim + if 'ifc4x3_rc4.ifcconic' in typeof(curve): + return curve.Position.Dim + if 'ifc4x3_rc4.ifcpolyline' in typeof(curve): + return curve.Points[1 - 1].Dim + if 'ifc4x3_rc4.ifctrimmedcurve' in typeof(curve): + return IfcCurveDim(curve.BasisCurve) + if 'ifc4x3_rc4.ifcgradientcurve' in typeof(curve): + return 3 + if 'ifc4x3_rc4.ifcsegmentedreferencecurve' in typeof(curve): + return 3 + if 'ifc4x3_rc4.ifccompositecurve' in typeof(curve): + return curve.Segments[1 - 1].Dim + if 'ifc4x3_rc4.ifcbsplinecurve' in typeof(curve): + return curve.ControlPointsList[1 - 1].Dim + if 'ifc4x3_rc4.ifcoffsetcurve2d' in typeof(curve): + return 2 + if 'ifc4x3_rc4.ifcoffsetcurve3d' in typeof(curve): + return 3 + if 'ifc4x3_rc4.ifcoffsetcurvebydistances' in typeof(curve): + return 3 + if 'ifc4x3_rc4.ifccurvesegment2d' in typeof(curve): + return 2 + if 'ifc4x3_rc4.ifcpolynomialcurve' in typeof(curve): + if (not exists(curve.CoefficientsZ)) and (curve.Position.Dim == 2): + return 2 + return 3 + if 'ifc4x3_rc4.ifcpcurve' in typeof(curve): + return 3 + if 'ifc4x3_rc4.ifcindexedpolycurve' in typeof(curve): + return curve.Points.Dim + return None + + +def IfcCurveWeightsPositive(b): + result = True + for i in range(0, b.UpperIndexOnControlPoints + 1): + if (b.Weights[i - 1]) <= 0.0: + result = False + return result + return result + + +def IfcDeriveDimensionalExponents(unitelements): + result = IfcDimensionalExponents(0,0,0,0,0,0,0) + for i in range(loindex(unitelements), hiindex(unitelements) + 1): + result.LengthExponent = result.LengthExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LengthExponent)) + result.MassExponent = result.MassExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.MassExponent)) + result.TimeExponent = result.TimeExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.TimeExponent)) + result.ElectricCurrentExponent = result.ElectricCurrentExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ElectricCurrentExponent)) + result.ThermodynamicTemperatureExponent = result.ThermodynamicTemperatureExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ThermodynamicTemperatureExponent)) + result.AmountOfSubstanceExponent = result.AmountOfSubstanceExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.AmountOfSubstanceExponent)) + result.LuminousIntensityExponent = result.LuminousIntensityExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LuminousIntensityExponent)) + return result + + +def IfcDimensionsForSiUnit(n): + + if n == metre: + return IfcDimensionalExponents(1,0,0,0,0,0,0) + elif n == square_metre: + return IfcDimensionalExponents(2,0,0,0,0,0,0) + elif n == cubic_metre: + return IfcDimensionalExponents(3,0,0,0,0,0,0) + elif n == gram: + return IfcDimensionalExponents(0,1,0,0,0,0,0) + elif n == second: + return IfcDimensionalExponents(0,0,1,0,0,0,0) + elif n == ampere: + return IfcDimensionalExponents(0,0,0,1,0,0,0) + elif n == kelvin: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == mole: + return IfcDimensionalExponents(0,0,0,0,0,1,0) + elif n == candela: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == radian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == steradian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == hertz: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == newton: + return IfcDimensionalExponents(1,1,-2,0,0,0,0) + elif n == pascal: + return IfcDimensionalExponents(-1,1,-2,0,0,0,0) + elif n == joule: + return IfcDimensionalExponents(2,1,-2,0,0,0,0) + elif n == watt: + return IfcDimensionalExponents(2,1,-3,0,0,0,0) + elif n == coulomb: + return IfcDimensionalExponents(0,0,1,1,0,0,0) + elif n == volt: + return IfcDimensionalExponents(2,1,-3,-1,0,0,0) + elif n == farad: + return IfcDimensionalExponents(-2,-1,4,2,0,0,0) + elif n == ohm: + return IfcDimensionalExponents(2,1,-3,-2,0,0,0) + elif n == siemens: + return IfcDimensionalExponents(-2,-1,3,2,0,0,0) + elif n == weber: + return IfcDimensionalExponents(2,1,-2,-1,0,0,0) + elif n == tesla: + return IfcDimensionalExponents(0,1,-2,-1,0,0,0) + elif n == henry: + return IfcDimensionalExponents(2,1,-2,-2,0,0,0) + elif n == degree_celsius: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == lumen: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == lux: + return IfcDimensionalExponents(-2,0,0,0,0,0,1) + elif n == becquerel: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == gray: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + elif n == sievert: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + else: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + + +def IfcDotProduct(arg1, arg2): + + + + if (not exists(arg1)) or (not exists(arg2)): + scalar = None + else: + if arg1.Dim != arg2.Dim: + scalar = None + else: + vec1 = IfcNormalise(arg1) + vec2 = IfcNormalise(arg2) + ndim = arg1.Dim + scalar = 0.0 + for i in range(1, ndim + 1): + scalar = scalar + ((vec1.DirectionRatios[i - 1]) * (vec2.DirectionRatios[i - 1])) + return scalar + + +def IfcFirstProjAxis(zaxis, arg): + + + + + if not exists(zaxis): + return None + else: + z = IfcNormalise(zaxis) + if not exists(arg): + if z.DirectionRatios != [1.0,0.0,0.0]: + v = IfcDirection(DirectionRatios=[1.0,0.0,0.0]) + else: + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + if arg.Dim != 3: + return None + if IfcCrossProduct(arg,z).Magnitude == 0.0: + return None + else: + v = IfcNormalise(arg) + xvec = IfcScalarTimesVector(IfcDotProduct(v,z),z) + xaxis = IfcVectorDifference(v,xvec).Orientation + xaxis = IfcNormalise(xaxis) + return xaxis + + +def IfcGetBasisSurface(c): + + + surfs = [] + if 'ifc4x3_rc4.ifcpcurve' in typeof(c): + surfs = [c.BasisSurface] + else: + if 'ifc4x3_rc4.ifcsurfacecurve' in typeof(c): + n = sizeof(c.AssociatedGeometry) + for i in range(1, n + 1): + surfs = surfs + (IfcAssociatedSurface(c.AssociatedGeometry[i - 1])) + if 'ifc4x3_rc4.ifccompositecurveonsurface' in typeof(c): + n = sizeof(c.Segments) + surfs = IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve) + if n > 1: + for i in range(2, n + 1): + surfs = surfs * (IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve)) + return surfs + + +def IfcGradient(gradientcurve): + + return 1 + + +def IfcListToArray(lis, low, u): + + + n = sizeof(lis) + if n != (u - low + 1): + return None + else: + res = ([lis[1 - 1]] * n) + for i in range(2, n + 1): + temp = list(res) + temp[low - 1] = lis[i - 1] + res = temp + return res + + +def IfcLoopHeadToTail(aloop): + + p = True + n = sizeof(aloop.EdgeList) + for i in range(2, n + 1): + p = p and ((aloop.EdgeList[i - 1].EdgeEnd) == (aloop.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcMakeArrayOfArray(lis, low1, u1, low2, u2): + + if (u1 - low1 + 1) != sizeof(lis): + return None + if (u2 - low2 + 1) != (sizeof(lis[1 - 1])): + return None + res = ([IfcListToArray(lis[1 - 1],low2,u2)] * u1 - low1 + 1) + for i in range(2, hiindex(lis) + 1): + if (u2 - low2 + 1) != (sizeof(lis[i - 1])): + return None + temp = list(res) + temp[low1 - 1] = IfcListToArray(lis[i - 1],low2,u2) + res = temp + return res + + +def IfcMlsTotalThickness(layerset): + max = layerset.MaterialLayers[1 - 1].LayerThickness + if sizeof(layerset.MaterialLayers) > 1: + for i in range(2, hiindex(layerset.MaterialLayers) + 1): + max = max + (layerset.MaterialLayers[i - 1].LayerThickness) + return max + + +def IfcNormalise(arg): + + v = IfcDirection(DirectionRatios=[1.,0.]) + vec = IfcVector(Orientation=IfcDirection(DirectionRatios=[1.,0.]), Magnitude=1.) + + result = v + if not exists(arg): + return None + else: + if 'ifc4x3_rc4.ifcvector' in typeof(arg): + ndim = arg.Dim + v.DirectionRatios = arg.Orientation.DirectionRatios + vec.Magnitude = arg.Magnitude + vec.Orientation = v + if arg.Magnitude == 0.0: + return None + else: + vec.Magnitude = 1.0 + else: + ndim = arg.Dim + v.DirectionRatios = arg.DirectionRatios + mag = 0.0 + for i in range(1, ndim + 1): + mag = mag + ((v.DirectionRatios[i - 1]) * (v.DirectionRatios[i - 1])) + if mag > 0.0: + mag = sqrt(mag) + for i in range(1, ndim + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = (v.DirectionRatios[i - 1]) / mag + v.DirectionRatios = temp + if 'ifc4x3_rc4.ifcvector' in typeof(arg): + vec.Orientation = v + result = vec + else: + result = v + else: + return None + return result + + +def IfcOrthogonalComplement(vec): + + if (not exists(vec)) or (vec.Dim != 2): + return None + else: + result = IfcDirection(DirectionRatios=[-vec.DirectionRatios[2 - 1],vec.DirectionRatios[1 - 1]]) + return result + + +def IfcPathHeadToTail(apath): + n = 0 + p = unknown + n = sizeof(apath.EdgeList) + for i in range(2, n + 1): + p = p and ((apath.EdgeList[i - 1].EdgeEnd) == (apath.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcPointListDim(pointlist): + + if 'ifc4x3_rc4.ifccartesianpointlist2d' in typeof(pointlist): + return 2 + if 'ifc4x3_rc4.ifccartesianpointlist3d' in typeof(pointlist): + return 3 + return None + + +def IfcSameAxis2Placement(ap1, ap2, epsilon): + + return (IfcSameDirection(ap1.P[1 - 1],ap2.P[1 - 1],epsilon)) and (IfcSameDirection(ap1.P[2 - 1],ap2.P[2 - 1],epsilon)) and IfcSameCartesianPoint(ap1.Location,ap1.Location,epsilon) + + +def IfcSameCartesianPoint(cp1, cp2, epsilon): + cp1x = cp1.Coordinates[1 - 1] + cp1y = cp1.Coordinates[2 - 1] + cp1z = 0 + cp2x = cp2.Coordinates[1 - 1] + cp2y = cp2.Coordinates[2 - 1] + cp2z = 0 + if sizeof(cp1.Coordinates) > 2: + cp1z = cp1.Coordinates[3 - 1] + if sizeof(cp2.Coordinates) > 2: + cp2z = cp2.Coordinates[3 - 1] + return IfcSameValue(cp1x,cp2x,epsilon) and IfcSameValue(cp1y,cp2y,epsilon) and IfcSameValue(cp1z,cp2z,epsilon) + + +def IfcSameDirection(dir1, dir2, epsilon): + dir1x = dir1.DirectionRatios[1 - 1] + dir1y = dir1.DirectionRatios[2 - 1] + dir1z = 0 + dir2x = dir2.DirectionRatios[1 - 1] + dir2y = dir2.DirectionRatios[2 - 1] + dir2z = 0 + if sizeof(dir1.DirectionRatios) > 2: + dir1z = dir1.DirectionRatios[3 - 1] + if sizeof(dir2.DirectionRatios) > 2: + dir2z = dir2.DirectionRatios[3 - 1] + return IfcSameValue(dir1x,dir2x,epsilon) and IfcSameValue(dir1y,dir2y,epsilon) and IfcSameValue(dir1z,dir2z,epsilon) + + +def IfcSameValidPrecision(epsilon1, epsilon2): + + defaulteps = 0.000001 + derivationofeps = 1.001 + uppereps = 1.0 + valideps1 = nvl(epsilon1,defaulteps) + valideps2 = nvl(epsilon2,defaulteps) + return (0.0 < valideps1) and (valideps1 <= (derivationofeps * valideps2)) and (valideps2 <= (derivationofeps * valideps1)) and (valideps2 < uppereps) + + +def IfcSameValue(value1, value2, epsilon): + + defaulteps = 0.000001 + valideps = nvl(epsilon,defaulteps) + return ((value1 + valideps) > value2) and (value1 < (value2 + valideps)) + + +def IfcScalarTimesVector(scalar, vec): + + + + if (not exists(scalar)) or (not exists(vec)): + return None + else: + if 'ifc4x3_rc4.ifcvector' in typeof(vec): + v = vec.Orientation + mag = scalar * vec.Magnitude + else: + v = vec + mag = scalar + if mag < 0.0: + for i in range(1, sizeof(v.DirectionRatios) + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = -v.DirectionRatios[i - 1] + v.DirectionRatios = temp + mag = -mag + result = IfcVector(Orientation=IfcNormalise(v), Magnitude=mag) + return result + + +def IfcSecondProjAxis(zaxis, xaxis, arg): + + + + if not exists(arg): + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + v = arg + temp = IfcScalarTimesVector(IfcDotProduct(v,zaxis),zaxis) + yaxis = IfcVectorDifference(v,temp) + temp = IfcScalarTimesVector(IfcDotProduct(v,xaxis),xaxis) + yaxis = IfcVectorDifference(yaxis,temp) + yaxis = IfcNormalise(yaxis) + return yaxis.Orientation + + +def IfcShapeRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'point': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifcpoint' in typeof(temp)]) + elif reptype.lower() == 'pointcloud': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifccartesianpointlist3d' in typeof(temp)]) + elif reptype.lower() == 'curve': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifccurve' in typeof(temp)]) + elif reptype.lower() == 'curve2d': + count = sizeof([temp for temp in items if ('ifc4x3_rc4.ifccurve' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'curve3d': + count = sizeof([temp for temp in items if ('ifc4x3_rc4.ifccurve' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'surface': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifcsurface' in typeof(temp)]) + elif reptype.lower() == 'surface2d': + count = sizeof([temp for temp in items if ('ifc4x3_rc4.ifcsurface' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'surface3d': + count = sizeof([temp for temp in items if ('ifc4x3_rc4.ifcsurface' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'fillarea': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifcannotationfillarea' in typeof(temp)]) + elif reptype.lower() == 'text': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifctextliteral' in typeof(temp)]) + elif reptype.lower() == 'advancedsurface': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifcbsplinesurface' in typeof(temp)]) + elif reptype.lower() == 'annotation2d': + count = sizeof([temp for temp in items if (sizeof(typeof(temp) * ['ifc4x3_rc4.ifcpoint','ifc4x3_rc4.ifccurve','ifc4x3_rc4.ifcgeometriccurveset','ifc4x3_rc4.ifcannotationfillarea','ifc4x3_rc4.ifctextliteral'])) == 1]) + elif reptype.lower() == 'geometricset': + count = sizeof([temp for temp in items if ('ifc4x3_rc4.ifcgeometricset' in typeof(temp)) or ('ifc4x3_rc4.ifcpoint' in typeof(temp)) or ('ifc4x3_rc4.ifccurve' in typeof(temp)) or ('ifc4x3_rc4.ifcsurface' in typeof(temp))]) + elif reptype.lower() == 'geometriccurveset': + count = sizeof([temp for temp in items if ('ifc4x3_rc4.ifcgeometriccurveset' in typeof(temp)) or ('ifc4x3_rc4.ifcgeometricset' in typeof(temp)) or ('ifc4x3_rc4.ifcpoint' in typeof(temp)) or ('ifc4x3_rc4.ifccurve' in typeof(temp))]) + for i in range(1, hiindex(items) + 1): + if 'ifc4x3_rc4.ifcgeometricset' in (typeof(items[i - 1])): + if (sizeof([temp for temp in items[i - 1].Elements if 'ifc4x3_rc4.ifcsurface' in typeof(temp)])) > 0: + count = count - 1 + elif reptype.lower() == 'tessellation': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifctessellateditem' in typeof(temp)]) + elif reptype.lower() == 'surfaceorsolidmodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc4.ifctessellateditem','ifc4x3_rc4.ifcshellbasedsurfacemodel','ifc4x3_rc4.ifcfacebasedsurfacemodel','ifc4x3_rc4.ifcsolidmodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'surfacemodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc4.ifctessellateditem','ifc4x3_rc4.ifcshellbasedsurfacemodel','ifc4x3_rc4.ifcfacebasedsurfacemodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'solidmodel': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifcsolidmodel' in typeof(temp)]) + elif reptype.lower() == 'sweptsolid': + count = sizeof([temp for temp in items if ((sizeof(['ifc4x3_rc4.ifcextrudedareasolid','ifc4x3_rc4.ifcrevolvedareasolid'] * typeof(temp))) >= 1) and ((sizeof(['ifc4x3_rc4.ifcextrudedareasolidtapered','ifc4x3_rc4.ifcrevolvedareasolidtapered'] * typeof(temp))) == 0)]) + elif reptype.lower() == 'advancedsweptsolid': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc4.ifcsweptareasolid','ifc4x3_rc4.ifcsweptdisksolid','ifc4x3_rc4.ifcsectionedsolidhorizontal'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'csg': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc4.ifcbooleanresult','ifc4x3_rc4.ifccsgprimitive3d','ifc4x3_rc4.ifccsgsolid'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'clipping': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_rc4.ifccsgsolid','ifc4x3_rc4.ifcbooleanclippingresult'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'brep': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifcfacetedbrep' in typeof(temp)]) + elif reptype.lower() == 'advancedbrep': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifcmanifoldsolidbrep' in typeof(temp)]) + elif reptype.lower() == 'boundingbox': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifcboundingbox' in typeof(temp)]) + if sizeof(items) > 1: + count = 0 + elif reptype.lower() == 'sectionedspine': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifcsectionedspine' in typeof(temp)]) + elif reptype.lower() == 'lightsource': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifclightsource' in typeof(temp)]) + elif reptype.lower() == 'mappedrepresentation': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifcmappeditem' in typeof(temp)]) + else: + return None + return count == sizeof(items) + + +def IfcSurfaceWeightsPositive(b): + result = True + weights = b.Weights + for i in range(0, b.UUpper + 1): + for j in range(0, b.VUpper + 1): + if (weights[i - 1][j - 1]) <= 0.0: + result = False + return result + return result + + +def IfcTaperedSweptAreaProfiles(startarea, endarea): + result = False + if 'ifc4x3_rc4.ifcparameterizedprofiledef' in typeof(startarea): + if 'ifc4x3_rc4.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = typeof(startarea) == typeof(endarea) + else: + if 'ifc4x3_rc4.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = False + return result + + +def IfcTopologyRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'vertex': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifcvertex' in typeof(temp)]) + elif reptype.lower() == 'edge': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifcedge' in typeof(temp)]) + elif reptype.lower() == 'path': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifcpath' in typeof(temp)]) + elif reptype.lower() == 'face': + count = sizeof([temp for temp in items if 'ifc4x3_rc4.ifcface' in typeof(temp)]) + elif reptype.lower() == 'shell': + count = sizeof([temp for temp in items if ('ifc4x3_rc4.ifcopenshell' in typeof(temp)) or ('ifc4x3_rc4.ifcclosedshell' in typeof(temp))]) + elif reptype.lower() == 'undefined': + return True + else: + return None + return count == sizeof(items) + + +def IfcUniqueDefinitionNames(relations): + + + properties = express_set([]) + + if sizeof(relations) == 0: + return True + for i in range(1, hiindex(relations) + 1): + definition = relations[i - 1].RelatingPropertyDefinition + if 'ifc4x3_rc4.ifcpropertysetdefinition' in typeof(definition): + properties = properties + definition + else: + if 'ifc4x3_rc4.ifcpropertysetdefinitionset' in typeof(definition): + definitionset = definition + for j in range(1, hiindex(definitionset) + 1): + properties = properties + (definitionset[j - 1]) + result = IfcUniquePropertySetNames(properties) + return result + + +def IfcUniquePropertyName(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniquePropertySetNames(properties): + names = express_set([]) + unnamed = 0 + for i in range(1, hiindex(properties) + 1): + if 'ifc4x3_rc4.ifcpropertyset' in (typeof(properties[i - 1])): + names = names + (properties[i - 1].Name) + else: + unnamed = unnamed + 1 + return (sizeof(names) + unnamed) == sizeof(properties) + + +def IfcUniquePropertyTemplateNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniqueQuantityNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcVectorDifference(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x3_rc4.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x3_rc4.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) - (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + +def IfcVectorSum(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x3_rc4.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x3_rc4.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) + (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + diff --git a/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_TC1.py b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_TC1.py new file mode 100644 index 0000000000..6fef1461dd --- /dev/null +++ b/src/ifcopenshell-python/ifcopenshell/express/rules/IFC4X3_TC1.py @@ -0,0 +1,25016 @@ +import ifcopenshell + +def exists(v): + if callable(v): + try: return v() is not None + except IndexError as e: return False + else: return v is not None + + + +def nvl(v, default): return v if v is not None else default + + +sizeof = len +hiindex = len +blength = len +loindex = lambda x: 1 +from math import * +unknown = 'UNKNOWN' + +def usedin(inst, ref_name): + if inst is None: + return [] + _, __, attr = ref_name.split('.') + def filter(): + for ref, attr_idx in inst.wrapped_data.file.get_inverse(inst, allow_duplicate=True, with_attribute_indices=True): + if ref.wrapped_data.get_attribute_names()[attr_idx].lower() == attr: + yield ref + return list(filter()) + + +class express_set(set): + def __rmul__(self, other): + return express_set(set(other) & self) + def __add__(self, other): + def make_list(v): + # Comply with 12.6.3 Union operator + if isinstance(v, (list, tuple, set, express_set)): + return list(v) + else: + return [v] + return express_set(list(self) + make_list(other)) + __radd__ = __add__ + def __repr__(self): + return repr(set(self)) + + +def typeof(inst): + if not inst: + # If V evaluates to indeterminate (?), an empty set is returned. + return express_set([]) + schema_name = inst.is_a(True).split('.')[0].lower() + def inner(): + decl = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(inst.is_a()) + while decl: + yield '.'.join((schema_name, decl.name().lower())) + decl = decl.supertype() + return express_set(inner()) + +class enum_namespace: + def __getattr__(self, k): + return k.upper() + + +IfcActionRequestTypeEnum = enum_namespace() + + +email = IfcActionRequestTypeEnum.EMAIL + + +fax = IfcActionRequestTypeEnum.FAX + + +phone = IfcActionRequestTypeEnum.PHONE + + +post = IfcActionRequestTypeEnum.POST + + +verbal = IfcActionRequestTypeEnum.VERBAL + + +userdefined = IfcActionRequestTypeEnum.USERDEFINED + + +notdefined = IfcActionRequestTypeEnum.NOTDEFINED + + +IfcActionSourceTypeEnum = enum_namespace() + + +brakes = IfcActionSourceTypeEnum.BRAKES + + +buoyancy = IfcActionSourceTypeEnum.BUOYANCY + + +completion_g1 = IfcActionSourceTypeEnum.COMPLETION_G1 + + +creep = IfcActionSourceTypeEnum.CREEP + + +current = IfcActionSourceTypeEnum.CURRENT + + +dead_load_g = IfcActionSourceTypeEnum.DEAD_LOAD_G + + +earthquake_e = IfcActionSourceTypeEnum.EARTHQUAKE_E + + +erection = IfcActionSourceTypeEnum.ERECTION + + +fire = IfcActionSourceTypeEnum.FIRE + + +ice = IfcActionSourceTypeEnum.ICE + + +impact = IfcActionSourceTypeEnum.IMPACT + + +impulse = IfcActionSourceTypeEnum.IMPULSE + + +lack_of_fit = IfcActionSourceTypeEnum.LACK_OF_FIT + + +live_load_q = IfcActionSourceTypeEnum.LIVE_LOAD_Q + + +prestressing_p = IfcActionSourceTypeEnum.PRESTRESSING_P + + +propping = IfcActionSourceTypeEnum.PROPPING + + +rain = IfcActionSourceTypeEnum.RAIN + + +settlement_u = IfcActionSourceTypeEnum.SETTLEMENT_U + + +shrinkage = IfcActionSourceTypeEnum.SHRINKAGE + + +snow_s = IfcActionSourceTypeEnum.SNOW_S + + +system_imperfection = IfcActionSourceTypeEnum.SYSTEM_IMPERFECTION + + +temperature_t = IfcActionSourceTypeEnum.TEMPERATURE_T + + +transport = IfcActionSourceTypeEnum.TRANSPORT + + +wave = IfcActionSourceTypeEnum.WAVE + + +wind_w = IfcActionSourceTypeEnum.WIND_W + + +userdefined = IfcActionSourceTypeEnum.USERDEFINED + + +notdefined = IfcActionSourceTypeEnum.NOTDEFINED + + +IfcActionTypeEnum = enum_namespace() + + +extraordinary_a = IfcActionTypeEnum.EXTRAORDINARY_A + + +permanent_g = IfcActionTypeEnum.PERMANENT_G + + +variable_q = IfcActionTypeEnum.VARIABLE_Q + + +userdefined = IfcActionTypeEnum.USERDEFINED + + +notdefined = IfcActionTypeEnum.NOTDEFINED + + +IfcActuatorTypeEnum = enum_namespace() + + +electricactuator = IfcActuatorTypeEnum.ELECTRICACTUATOR + + +handoperatedactuator = IfcActuatorTypeEnum.HANDOPERATEDACTUATOR + + +hydraulicactuator = IfcActuatorTypeEnum.HYDRAULICACTUATOR + + +pneumaticactuator = IfcActuatorTypeEnum.PNEUMATICACTUATOR + + +thermostaticactuator = IfcActuatorTypeEnum.THERMOSTATICACTUATOR + + +userdefined = IfcActuatorTypeEnum.USERDEFINED + + +notdefined = IfcActuatorTypeEnum.NOTDEFINED + + +IfcAddressTypeEnum = enum_namespace() + + +distributionpoint = IfcAddressTypeEnum.DISTRIBUTIONPOINT + + +home = IfcAddressTypeEnum.HOME + + +office = IfcAddressTypeEnum.OFFICE + + +site = IfcAddressTypeEnum.SITE + + +userdefined = IfcAddressTypeEnum.USERDEFINED + + +IfcAirTerminalBoxTypeEnum = enum_namespace() + + +constantflow = IfcAirTerminalBoxTypeEnum.CONSTANTFLOW + + +variableflowpressuredependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREDEPENDANT + + +variableflowpressureindependant = IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREINDEPENDANT + + +userdefined = IfcAirTerminalBoxTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalBoxTypeEnum.NOTDEFINED + + +IfcAirTerminalTypeEnum = enum_namespace() + + +diffuser = IfcAirTerminalTypeEnum.DIFFUSER + + +grille = IfcAirTerminalTypeEnum.GRILLE + + +louvre = IfcAirTerminalTypeEnum.LOUVRE + + +register = IfcAirTerminalTypeEnum.REGISTER + + +userdefined = IfcAirTerminalTypeEnum.USERDEFINED + + +notdefined = IfcAirTerminalTypeEnum.NOTDEFINED + + +IfcAirToAirHeatRecoveryTypeEnum = enum_namespace() + + +fixedplatecounterflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECOUNTERFLOWEXCHANGER + + +fixedplatecrossflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECROSSFLOWEXCHANGER + + +fixedplateparallelflowexchanger = IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATEPARALLELFLOWEXCHANGER + + +heatpipe = IfcAirToAirHeatRecoveryTypeEnum.HEATPIPE + + +rotarywheel = IfcAirToAirHeatRecoveryTypeEnum.ROTARYWHEEL + + +runaroundcoilloop = IfcAirToAirHeatRecoveryTypeEnum.RUNAROUNDCOILLOOP + + +thermosiphoncoiltypeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONCOILTYPEHEATEXCHANGERS + + +thermosiphonsealedtubeheatexchangers = IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONSEALEDTUBEHEATEXCHANGERS + + +twintowerenthalpyrecoveryloops = IfcAirToAirHeatRecoveryTypeEnum.TWINTOWERENTHALPYRECOVERYLOOPS + + +userdefined = IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED + + +notdefined = IfcAirToAirHeatRecoveryTypeEnum.NOTDEFINED + + +IfcAlarmTypeEnum = enum_namespace() + + +bell = IfcAlarmTypeEnum.BELL + + +breakglassbutton = IfcAlarmTypeEnum.BREAKGLASSBUTTON + + +light = IfcAlarmTypeEnum.LIGHT + + +manualpullbox = IfcAlarmTypeEnum.MANUALPULLBOX + + +railwaycrocodile = IfcAlarmTypeEnum.RAILWAYCROCODILE + + +railwaydetonator = IfcAlarmTypeEnum.RAILWAYDETONATOR + + +siren = IfcAlarmTypeEnum.SIREN + + +whistle = IfcAlarmTypeEnum.WHISTLE + + +userdefined = IfcAlarmTypeEnum.USERDEFINED + + +notdefined = IfcAlarmTypeEnum.NOTDEFINED + + +IfcAlignmentCantSegmentTypeEnum = enum_namespace() + + +blosscurve = IfcAlignmentCantSegmentTypeEnum.BLOSSCURVE + + +constantcant = IfcAlignmentCantSegmentTypeEnum.CONSTANTCANT + + +cosinecurve = IfcAlignmentCantSegmentTypeEnum.COSINECURVE + + +helmertcurve = IfcAlignmentCantSegmentTypeEnum.HELMERTCURVE + + +lineartransition = IfcAlignmentCantSegmentTypeEnum.LINEARTRANSITION + + +sinecurve = IfcAlignmentCantSegmentTypeEnum.SINECURVE + + +viennesebend = IfcAlignmentCantSegmentTypeEnum.VIENNESEBEND + + +IfcAlignmentHorizontalSegmentTypeEnum = enum_namespace() + + +blosscurve = IfcAlignmentHorizontalSegmentTypeEnum.BLOSSCURVE + + +circulararc = IfcAlignmentHorizontalSegmentTypeEnum.CIRCULARARC + + +clothoid = IfcAlignmentHorizontalSegmentTypeEnum.CLOTHOID + + +cosinecurve = IfcAlignmentHorizontalSegmentTypeEnum.COSINECURVE + + +cubic = IfcAlignmentHorizontalSegmentTypeEnum.CUBIC + + +helmertcurve = IfcAlignmentHorizontalSegmentTypeEnum.HELMERTCURVE + + +line = IfcAlignmentHorizontalSegmentTypeEnum.LINE + + +sinecurve = IfcAlignmentHorizontalSegmentTypeEnum.SINECURVE + + +viennesebend = IfcAlignmentHorizontalSegmentTypeEnum.VIENNESEBEND + + +IfcAlignmentTypeEnum = enum_namespace() + + +userdefined = IfcAlignmentTypeEnum.USERDEFINED + + +notdefined = IfcAlignmentTypeEnum.NOTDEFINED + + +IfcAlignmentVerticalSegmentTypeEnum = enum_namespace() + + +circulararc = IfcAlignmentVerticalSegmentTypeEnum.CIRCULARARC + + +clothoid = IfcAlignmentVerticalSegmentTypeEnum.CLOTHOID + + +constantgradient = IfcAlignmentVerticalSegmentTypeEnum.CONSTANTGRADIENT + + +parabolicarc = IfcAlignmentVerticalSegmentTypeEnum.PARABOLICARC + + +IfcAnalysisModelTypeEnum = enum_namespace() + + +in_plane_loading_2d = IfcAnalysisModelTypeEnum.IN_PLANE_LOADING_2D + + +loading_3d = IfcAnalysisModelTypeEnum.LOADING_3D + + +out_plane_loading_2d = IfcAnalysisModelTypeEnum.OUT_PLANE_LOADING_2D + + +userdefined = IfcAnalysisModelTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisModelTypeEnum.NOTDEFINED + + +IfcAnalysisTheoryTypeEnum = enum_namespace() + + +first_order_theory = IfcAnalysisTheoryTypeEnum.FIRST_ORDER_THEORY + + +full_nonlinear_theory = IfcAnalysisTheoryTypeEnum.FULL_NONLINEAR_THEORY + + +second_order_theory = IfcAnalysisTheoryTypeEnum.SECOND_ORDER_THEORY + + +third_order_theory = IfcAnalysisTheoryTypeEnum.THIRD_ORDER_THEORY + + +userdefined = IfcAnalysisTheoryTypeEnum.USERDEFINED + + +notdefined = IfcAnalysisTheoryTypeEnum.NOTDEFINED + + +IfcAnnotationTypeEnum = enum_namespace() + + +asbuiltarea = IfcAnnotationTypeEnum.ASBUILTAREA + + +asbuiltline = IfcAnnotationTypeEnum.ASBUILTLINE + + +asbuiltpoint = IfcAnnotationTypeEnum.ASBUILTPOINT + + +assumedarea = IfcAnnotationTypeEnum.ASSUMEDAREA + + +assumedline = IfcAnnotationTypeEnum.ASSUMEDLINE + + +assumedpoint = IfcAnnotationTypeEnum.ASSUMEDPOINT + + +non_physical_signal = IfcAnnotationTypeEnum.NON_PHYSICAL_SIGNAL + + +superelevationevent = IfcAnnotationTypeEnum.SUPERELEVATIONEVENT + + +widthevent = IfcAnnotationTypeEnum.WIDTHEVENT + + +userdefined = IfcAnnotationTypeEnum.USERDEFINED + + +notdefined = IfcAnnotationTypeEnum.NOTDEFINED + + +IfcArithmeticOperatorEnum = enum_namespace() + + +add = IfcArithmeticOperatorEnum.ADD + + +divide = IfcArithmeticOperatorEnum.DIVIDE + + +multiply = IfcArithmeticOperatorEnum.MULTIPLY + + +subtract = IfcArithmeticOperatorEnum.SUBTRACT + + +IfcAssemblyPlaceEnum = enum_namespace() + + +factory = IfcAssemblyPlaceEnum.FACTORY + + +site = IfcAssemblyPlaceEnum.SITE + + +notdefined = IfcAssemblyPlaceEnum.NOTDEFINED + + +IfcAudioVisualApplianceTypeEnum = enum_namespace() + + +amplifier = IfcAudioVisualApplianceTypeEnum.AMPLIFIER + + +camera = IfcAudioVisualApplianceTypeEnum.CAMERA + + +communicationterminal = IfcAudioVisualApplianceTypeEnum.COMMUNICATIONTERMINAL + + +display = IfcAudioVisualApplianceTypeEnum.DISPLAY + + +microphone = IfcAudioVisualApplianceTypeEnum.MICROPHONE + + +player = IfcAudioVisualApplianceTypeEnum.PLAYER + + +projector = IfcAudioVisualApplianceTypeEnum.PROJECTOR + + +receiver = IfcAudioVisualApplianceTypeEnum.RECEIVER + + +recordingequipment = IfcAudioVisualApplianceTypeEnum.RECORDINGEQUIPMENT + + +speaker = IfcAudioVisualApplianceTypeEnum.SPEAKER + + +switcher = IfcAudioVisualApplianceTypeEnum.SWITCHER + + +telephone = IfcAudioVisualApplianceTypeEnum.TELEPHONE + + +tuner = IfcAudioVisualApplianceTypeEnum.TUNER + + +userdefined = IfcAudioVisualApplianceTypeEnum.USERDEFINED + + +notdefined = IfcAudioVisualApplianceTypeEnum.NOTDEFINED + + +IfcBSplineCurveForm = enum_namespace() + + +circular_arc = IfcBSplineCurveForm.CIRCULAR_ARC + + +elliptic_arc = IfcBSplineCurveForm.ELLIPTIC_ARC + + +hyperbolic_arc = IfcBSplineCurveForm.HYPERBOLIC_ARC + + +parabolic_arc = IfcBSplineCurveForm.PARABOLIC_ARC + + +polyline_form = IfcBSplineCurveForm.POLYLINE_FORM + + +unspecified = IfcBSplineCurveForm.UNSPECIFIED + + +IfcBSplineSurfaceForm = enum_namespace() + + +conical_surf = IfcBSplineSurfaceForm.CONICAL_SURF + + +cylindrical_surf = IfcBSplineSurfaceForm.CYLINDRICAL_SURF + + +generalised_cone = IfcBSplineSurfaceForm.GENERALISED_CONE + + +plane_surf = IfcBSplineSurfaceForm.PLANE_SURF + + +quadric_surf = IfcBSplineSurfaceForm.QUADRIC_SURF + + +ruled_surf = IfcBSplineSurfaceForm.RULED_SURF + + +spherical_surf = IfcBSplineSurfaceForm.SPHERICAL_SURF + + +surf_of_linear_extrusion = IfcBSplineSurfaceForm.SURF_OF_LINEAR_EXTRUSION + + +surf_of_revolution = IfcBSplineSurfaceForm.SURF_OF_REVOLUTION + + +toroidal_surf = IfcBSplineSurfaceForm.TOROIDAL_SURF + + +unspecified = IfcBSplineSurfaceForm.UNSPECIFIED + + +IfcBeamTypeEnum = enum_namespace() + + +beam = IfcBeamTypeEnum.BEAM + + +cornice = IfcBeamTypeEnum.CORNICE + + +diaphragm = IfcBeamTypeEnum.DIAPHRAGM + + +edgebeam = IfcBeamTypeEnum.EDGEBEAM + + +girder_segment = IfcBeamTypeEnum.GIRDER_SEGMENT + + +hatstone = IfcBeamTypeEnum.HATSTONE + + +hollowcore = IfcBeamTypeEnum.HOLLOWCORE + + +joist = IfcBeamTypeEnum.JOIST + + +lintel = IfcBeamTypeEnum.LINTEL + + +piercap = IfcBeamTypeEnum.PIERCAP + + +spandrel = IfcBeamTypeEnum.SPANDREL + + +t_beam = IfcBeamTypeEnum.T_BEAM + + +userdefined = IfcBeamTypeEnum.USERDEFINED + + +notdefined = IfcBeamTypeEnum.NOTDEFINED + + +IfcBearingTypeEnum = enum_namespace() + + +cylindrical = IfcBearingTypeEnum.CYLINDRICAL + + +disk = IfcBearingTypeEnum.DISK + + +elastomeric = IfcBearingTypeEnum.ELASTOMERIC + + +guide = IfcBearingTypeEnum.GUIDE + + +pot = IfcBearingTypeEnum.POT + + +rocker = IfcBearingTypeEnum.ROCKER + + +roller = IfcBearingTypeEnum.ROLLER + + +spherical = IfcBearingTypeEnum.SPHERICAL + + +userdefined = IfcBearingTypeEnum.USERDEFINED + + +notdefined = IfcBearingTypeEnum.NOTDEFINED + + +IfcBenchmarkEnum = enum_namespace() + + +equalto = IfcBenchmarkEnum.EQUALTO + + +greaterthan = IfcBenchmarkEnum.GREATERTHAN + + +greaterthanorequalto = IfcBenchmarkEnum.GREATERTHANOREQUALTO + + +includedin = IfcBenchmarkEnum.INCLUDEDIN + + +includes = IfcBenchmarkEnum.INCLUDES + + +lessthan = IfcBenchmarkEnum.LESSTHAN + + +lessthanorequalto = IfcBenchmarkEnum.LESSTHANOREQUALTO + + +notequalto = IfcBenchmarkEnum.NOTEQUALTO + + +notincludedin = IfcBenchmarkEnum.NOTINCLUDEDIN + + +notincludes = IfcBenchmarkEnum.NOTINCLUDES + + +IfcBoilerTypeEnum = enum_namespace() + + +steam = IfcBoilerTypeEnum.STEAM + + +water = IfcBoilerTypeEnum.WATER + + +userdefined = IfcBoilerTypeEnum.USERDEFINED + + +notdefined = IfcBoilerTypeEnum.NOTDEFINED + + +IfcBooleanOperator = enum_namespace() + + +difference = IfcBooleanOperator.DIFFERENCE + + +intersection = IfcBooleanOperator.INTERSECTION + + +union = IfcBooleanOperator.UNION + + +IfcBridgePartTypeEnum = enum_namespace() + + +abutment = IfcBridgePartTypeEnum.ABUTMENT + + +deck = IfcBridgePartTypeEnum.DECK + + +deck_segment = IfcBridgePartTypeEnum.DECK_SEGMENT + + +foundation = IfcBridgePartTypeEnum.FOUNDATION + + +pier = IfcBridgePartTypeEnum.PIER + + +pier_segment = IfcBridgePartTypeEnum.PIER_SEGMENT + + +pylon = IfcBridgePartTypeEnum.PYLON + + +substructure = IfcBridgePartTypeEnum.SUBSTRUCTURE + + +superstructure = IfcBridgePartTypeEnum.SUPERSTRUCTURE + + +surfacestructure = IfcBridgePartTypeEnum.SURFACESTRUCTURE + + +userdefined = IfcBridgePartTypeEnum.USERDEFINED + + +notdefined = IfcBridgePartTypeEnum.NOTDEFINED + + +IfcBridgeTypeEnum = enum_namespace() + + +arched = IfcBridgeTypeEnum.ARCHED + + +cable_stayed = IfcBridgeTypeEnum.CABLE_STAYED + + +cantilever = IfcBridgeTypeEnum.CANTILEVER + + +culvert = IfcBridgeTypeEnum.CULVERT + + +framework = IfcBridgeTypeEnum.FRAMEWORK + + +girder = IfcBridgeTypeEnum.GIRDER + + +suspension = IfcBridgeTypeEnum.SUSPENSION + + +truss = IfcBridgeTypeEnum.TRUSS + + +userdefined = IfcBridgeTypeEnum.USERDEFINED + + +notdefined = IfcBridgeTypeEnum.NOTDEFINED + + +IfcBuildingElementPartTypeEnum = enum_namespace() + + +apron = IfcBuildingElementPartTypeEnum.APRON + + +armourunit = IfcBuildingElementPartTypeEnum.ARMOURUNIT + + +insulation = IfcBuildingElementPartTypeEnum.INSULATION + + +precastpanel = IfcBuildingElementPartTypeEnum.PRECASTPANEL + + +safetycage = IfcBuildingElementPartTypeEnum.SAFETYCAGE + + +userdefined = IfcBuildingElementPartTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementPartTypeEnum.NOTDEFINED + + +IfcBuildingElementProxyTypeEnum = enum_namespace() + + +complex = IfcBuildingElementProxyTypeEnum.COMPLEX + + +element = IfcBuildingElementProxyTypeEnum.ELEMENT + + +partial = IfcBuildingElementProxyTypeEnum.PARTIAL + + +provisionforspace = IfcBuildingElementProxyTypeEnum.PROVISIONFORSPACE + + +provisionforvoid = IfcBuildingElementProxyTypeEnum.PROVISIONFORVOID + + +userdefined = IfcBuildingElementProxyTypeEnum.USERDEFINED + + +notdefined = IfcBuildingElementProxyTypeEnum.NOTDEFINED + + +IfcBuildingSystemTypeEnum = enum_namespace() + + +fenestration = IfcBuildingSystemTypeEnum.FENESTRATION + + +foundation = IfcBuildingSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuildingSystemTypeEnum.LOADBEARING + + +outershell = IfcBuildingSystemTypeEnum.OUTERSHELL + + +shading = IfcBuildingSystemTypeEnum.SHADING + + +transport = IfcBuildingSystemTypeEnum.TRANSPORT + + +userdefined = IfcBuildingSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuildingSystemTypeEnum.NOTDEFINED + + +IfcBuiltSystemTypeEnum = enum_namespace() + + +erosionprevention = IfcBuiltSystemTypeEnum.EROSIONPREVENTION + + +fenestration = IfcBuiltSystemTypeEnum.FENESTRATION + + +foundation = IfcBuiltSystemTypeEnum.FOUNDATION + + +loadbearing = IfcBuiltSystemTypeEnum.LOADBEARING + + +mooring = IfcBuiltSystemTypeEnum.MOORING + + +outershell = IfcBuiltSystemTypeEnum.OUTERSHELL + + +prestressing = IfcBuiltSystemTypeEnum.PRESTRESSING + + +railwayline = IfcBuiltSystemTypeEnum.RAILWAYLINE + + +railwaytrack = IfcBuiltSystemTypeEnum.RAILWAYTRACK + + +reinforcing = IfcBuiltSystemTypeEnum.REINFORCING + + +shading = IfcBuiltSystemTypeEnum.SHADING + + +trackcircuit = IfcBuiltSystemTypeEnum.TRACKCIRCUIT + + +transport = IfcBuiltSystemTypeEnum.TRANSPORT + + +userdefined = IfcBuiltSystemTypeEnum.USERDEFINED + + +notdefined = IfcBuiltSystemTypeEnum.NOTDEFINED + + +IfcBurnerTypeEnum = enum_namespace() + + +userdefined = IfcBurnerTypeEnum.USERDEFINED + + +notdefined = IfcBurnerTypeEnum.NOTDEFINED + + +IfcCableCarrierFittingTypeEnum = enum_namespace() + + +bend = IfcCableCarrierFittingTypeEnum.BEND + + +connector = IfcCableCarrierFittingTypeEnum.CONNECTOR + + +cross = IfcCableCarrierFittingTypeEnum.CROSS + + +junction = IfcCableCarrierFittingTypeEnum.JUNCTION + + +reducer = IfcCableCarrierFittingTypeEnum.REDUCER + + +tee = IfcCableCarrierFittingTypeEnum.TEE + + +transition = IfcCableCarrierFittingTypeEnum.TRANSITION + + +userdefined = IfcCableCarrierFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierFittingTypeEnum.NOTDEFINED + + +IfcCableCarrierSegmentTypeEnum = enum_namespace() + + +cablebracket = IfcCableCarrierSegmentTypeEnum.CABLEBRACKET + + +cableladdersegment = IfcCableCarrierSegmentTypeEnum.CABLELADDERSEGMENT + + +cabletraysegment = IfcCableCarrierSegmentTypeEnum.CABLETRAYSEGMENT + + +cabletrunkingsegment = IfcCableCarrierSegmentTypeEnum.CABLETRUNKINGSEGMENT + + +catenarywire = IfcCableCarrierSegmentTypeEnum.CATENARYWIRE + + +conduitsegment = IfcCableCarrierSegmentTypeEnum.CONDUITSEGMENT + + +dropper = IfcCableCarrierSegmentTypeEnum.DROPPER + + +userdefined = IfcCableCarrierSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableCarrierSegmentTypeEnum.NOTDEFINED + + +IfcCableFittingTypeEnum = enum_namespace() + + +connector = IfcCableFittingTypeEnum.CONNECTOR + + +entry = IfcCableFittingTypeEnum.ENTRY + + +exit = IfcCableFittingTypeEnum.EXIT + + +fanout = IfcCableFittingTypeEnum.FANOUT + + +junction = IfcCableFittingTypeEnum.JUNCTION + + +transition = IfcCableFittingTypeEnum.TRANSITION + + +userdefined = IfcCableFittingTypeEnum.USERDEFINED + + +notdefined = IfcCableFittingTypeEnum.NOTDEFINED + + +IfcCableSegmentTypeEnum = enum_namespace() + + +busbarsegment = IfcCableSegmentTypeEnum.BUSBARSEGMENT + + +cablesegment = IfcCableSegmentTypeEnum.CABLESEGMENT + + +conductorsegment = IfcCableSegmentTypeEnum.CONDUCTORSEGMENT + + +contactwiresegment = IfcCableSegmentTypeEnum.CONTACTWIRESEGMENT + + +coresegment = IfcCableSegmentTypeEnum.CORESEGMENT + + +fibersegment = IfcCableSegmentTypeEnum.FIBERSEGMENT + + +fibertube = IfcCableSegmentTypeEnum.FIBERTUBE + + +opticalcablesegment = IfcCableSegmentTypeEnum.OPTICALCABLESEGMENT + + +stitchwire = IfcCableSegmentTypeEnum.STITCHWIRE + + +wirepairsegment = IfcCableSegmentTypeEnum.WIREPAIRSEGMENT + + +userdefined = IfcCableSegmentTypeEnum.USERDEFINED + + +notdefined = IfcCableSegmentTypeEnum.NOTDEFINED + + +IfcCaissonFoundationTypeEnum = enum_namespace() + + +caisson = IfcCaissonFoundationTypeEnum.CAISSON + + +well = IfcCaissonFoundationTypeEnum.WELL + + +userdefined = IfcCaissonFoundationTypeEnum.USERDEFINED + + +notdefined = IfcCaissonFoundationTypeEnum.NOTDEFINED + + +IfcChangeActionEnum = enum_namespace() + + +added = IfcChangeActionEnum.ADDED + + +deleted = IfcChangeActionEnum.DELETED + + +modified = IfcChangeActionEnum.MODIFIED + + +nochange = IfcChangeActionEnum.NOCHANGE + + +notdefined = IfcChangeActionEnum.NOTDEFINED + + +IfcChillerTypeEnum = enum_namespace() + + +aircooled = IfcChillerTypeEnum.AIRCOOLED + + +heatrecovery = IfcChillerTypeEnum.HEATRECOVERY + + +watercooled = IfcChillerTypeEnum.WATERCOOLED + + +userdefined = IfcChillerTypeEnum.USERDEFINED + + +notdefined = IfcChillerTypeEnum.NOTDEFINED + + +IfcChimneyTypeEnum = enum_namespace() + + +userdefined = IfcChimneyTypeEnum.USERDEFINED + + +notdefined = IfcChimneyTypeEnum.NOTDEFINED + + +IfcCoilTypeEnum = enum_namespace() + + +dxcoolingcoil = IfcCoilTypeEnum.DXCOOLINGCOIL + + +electricheatingcoil = IfcCoilTypeEnum.ELECTRICHEATINGCOIL + + +gasheatingcoil = IfcCoilTypeEnum.GASHEATINGCOIL + + +hydroniccoil = IfcCoilTypeEnum.HYDRONICCOIL + + +steamheatingcoil = IfcCoilTypeEnum.STEAMHEATINGCOIL + + +watercoolingcoil = IfcCoilTypeEnum.WATERCOOLINGCOIL + + +waterheatingcoil = IfcCoilTypeEnum.WATERHEATINGCOIL + + +userdefined = IfcCoilTypeEnum.USERDEFINED + + +notdefined = IfcCoilTypeEnum.NOTDEFINED + + +IfcColumnTypeEnum = enum_namespace() + + +column = IfcColumnTypeEnum.COLUMN + + +pierstem = IfcColumnTypeEnum.PIERSTEM + + +pierstem_segment = IfcColumnTypeEnum.PIERSTEM_SEGMENT + + +pilaster = IfcColumnTypeEnum.PILASTER + + +standcolumn = IfcColumnTypeEnum.STANDCOLUMN + + +userdefined = IfcColumnTypeEnum.USERDEFINED + + +notdefined = IfcColumnTypeEnum.NOTDEFINED + + +IfcCommunicationsApplianceTypeEnum = enum_namespace() + + +antenna = IfcCommunicationsApplianceTypeEnum.ANTENNA + + +automaton = IfcCommunicationsApplianceTypeEnum.AUTOMATON + + +computer = IfcCommunicationsApplianceTypeEnum.COMPUTER + + +fax = IfcCommunicationsApplianceTypeEnum.FAX + + +gateway = IfcCommunicationsApplianceTypeEnum.GATEWAY + + +intelligentperipheral = IfcCommunicationsApplianceTypeEnum.INTELLIGENTPERIPHERAL + + +ipnetworkequipment = IfcCommunicationsApplianceTypeEnum.IPNETWORKEQUIPMENT + + +linesideelectronicunit = IfcCommunicationsApplianceTypeEnum.LINESIDEELECTRONICUNIT + + +modem = IfcCommunicationsApplianceTypeEnum.MODEM + + +networkappliance = IfcCommunicationsApplianceTypeEnum.NETWORKAPPLIANCE + + +networkbridge = IfcCommunicationsApplianceTypeEnum.NETWORKBRIDGE + + +networkhub = IfcCommunicationsApplianceTypeEnum.NETWORKHUB + + +opticallineterminal = IfcCommunicationsApplianceTypeEnum.OPTICALLINETERMINAL + + +opticalnetworkunit = IfcCommunicationsApplianceTypeEnum.OPTICALNETWORKUNIT + + +printer = IfcCommunicationsApplianceTypeEnum.PRINTER + + +radioblockcenter = IfcCommunicationsApplianceTypeEnum.RADIOBLOCKCENTER + + +repeater = IfcCommunicationsApplianceTypeEnum.REPEATER + + +router = IfcCommunicationsApplianceTypeEnum.ROUTER + + +scanner = IfcCommunicationsApplianceTypeEnum.SCANNER + + +telecommand = IfcCommunicationsApplianceTypeEnum.TELECOMMAND + + +telephonyexchange = IfcCommunicationsApplianceTypeEnum.TELEPHONYEXCHANGE + + +transitioncomponent = IfcCommunicationsApplianceTypeEnum.TRANSITIONCOMPONENT + + +transponder = IfcCommunicationsApplianceTypeEnum.TRANSPONDER + + +transportequipment = IfcCommunicationsApplianceTypeEnum.TRANSPORTEQUIPMENT + + +userdefined = IfcCommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcCommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcComplexPropertyTemplateTypeEnum = enum_namespace() + + +p_complex = IfcComplexPropertyTemplateTypeEnum.P_COMPLEX + + +q_complex = IfcComplexPropertyTemplateTypeEnum.Q_COMPLEX + + +IfcCompressorTypeEnum = enum_namespace() + + +booster = IfcCompressorTypeEnum.BOOSTER + + +dynamic = IfcCompressorTypeEnum.DYNAMIC + + +hermetic = IfcCompressorTypeEnum.HERMETIC + + +opentype = IfcCompressorTypeEnum.OPENTYPE + + +reciprocating = IfcCompressorTypeEnum.RECIPROCATING + + +rollingpiston = IfcCompressorTypeEnum.ROLLINGPISTON + + +rotary = IfcCompressorTypeEnum.ROTARY + + +rotaryvane = IfcCompressorTypeEnum.ROTARYVANE + + +scroll = IfcCompressorTypeEnum.SCROLL + + +semihermetic = IfcCompressorTypeEnum.SEMIHERMETIC + + +singlescrew = IfcCompressorTypeEnum.SINGLESCREW + + +singlestage = IfcCompressorTypeEnum.SINGLESTAGE + + +trochoidal = IfcCompressorTypeEnum.TROCHOIDAL + + +twinscrew = IfcCompressorTypeEnum.TWINSCREW + + +weldedshellhermetic = IfcCompressorTypeEnum.WELDEDSHELLHERMETIC + + +userdefined = IfcCompressorTypeEnum.USERDEFINED + + +notdefined = IfcCompressorTypeEnum.NOTDEFINED + + +IfcCondenserTypeEnum = enum_namespace() + + +aircooled = IfcCondenserTypeEnum.AIRCOOLED + + +evaporativecooled = IfcCondenserTypeEnum.EVAPORATIVECOOLED + + +watercooled = IfcCondenserTypeEnum.WATERCOOLED + + +watercooledbrazedplate = IfcCondenserTypeEnum.WATERCOOLEDBRAZEDPLATE + + +watercooledshellcoil = IfcCondenserTypeEnum.WATERCOOLEDSHELLCOIL + + +watercooledshelltube = IfcCondenserTypeEnum.WATERCOOLEDSHELLTUBE + + +watercooledtubeintube = IfcCondenserTypeEnum.WATERCOOLEDTUBEINTUBE + + +userdefined = IfcCondenserTypeEnum.USERDEFINED + + +notdefined = IfcCondenserTypeEnum.NOTDEFINED + + +IfcConnectionTypeEnum = enum_namespace() + + +atend = IfcConnectionTypeEnum.ATEND + + +atpath = IfcConnectionTypeEnum.ATPATH + + +atstart = IfcConnectionTypeEnum.ATSTART + + +notdefined = IfcConnectionTypeEnum.NOTDEFINED + + +IfcConstraintEnum = enum_namespace() + + +advisory = IfcConstraintEnum.ADVISORY + + +hard = IfcConstraintEnum.HARD + + +soft = IfcConstraintEnum.SOFT + + +userdefined = IfcConstraintEnum.USERDEFINED + + +notdefined = IfcConstraintEnum.NOTDEFINED + + +IfcConstructionEquipmentResourceTypeEnum = enum_namespace() + + +demolishing = IfcConstructionEquipmentResourceTypeEnum.DEMOLISHING + + +earthmoving = IfcConstructionEquipmentResourceTypeEnum.EARTHMOVING + + +erecting = IfcConstructionEquipmentResourceTypeEnum.ERECTING + + +heating = IfcConstructionEquipmentResourceTypeEnum.HEATING + + +lighting = IfcConstructionEquipmentResourceTypeEnum.LIGHTING + + +paving = IfcConstructionEquipmentResourceTypeEnum.PAVING + + +pumping = IfcConstructionEquipmentResourceTypeEnum.PUMPING + + +transporting = IfcConstructionEquipmentResourceTypeEnum.TRANSPORTING + + +userdefined = IfcConstructionEquipmentResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionEquipmentResourceTypeEnum.NOTDEFINED + + +IfcConstructionMaterialResourceTypeEnum = enum_namespace() + + +aggregates = IfcConstructionMaterialResourceTypeEnum.AGGREGATES + + +concrete = IfcConstructionMaterialResourceTypeEnum.CONCRETE + + +drywall = IfcConstructionMaterialResourceTypeEnum.DRYWALL + + +fuel = IfcConstructionMaterialResourceTypeEnum.FUEL + + +gypsum = IfcConstructionMaterialResourceTypeEnum.GYPSUM + + +masonry = IfcConstructionMaterialResourceTypeEnum.MASONRY + + +metal = IfcConstructionMaterialResourceTypeEnum.METAL + + +plastic = IfcConstructionMaterialResourceTypeEnum.PLASTIC + + +wood = IfcConstructionMaterialResourceTypeEnum.WOOD + + +userdefined = IfcConstructionMaterialResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionMaterialResourceTypeEnum.NOTDEFINED + + +IfcConstructionProductResourceTypeEnum = enum_namespace() + + +assembly = IfcConstructionProductResourceTypeEnum.ASSEMBLY + + +formwork = IfcConstructionProductResourceTypeEnum.FORMWORK + + +userdefined = IfcConstructionProductResourceTypeEnum.USERDEFINED + + +notdefined = IfcConstructionProductResourceTypeEnum.NOTDEFINED + + +IfcControllerTypeEnum = enum_namespace() + + +floating = IfcControllerTypeEnum.FLOATING + + +multiposition = IfcControllerTypeEnum.MULTIPOSITION + + +programmable = IfcControllerTypeEnum.PROGRAMMABLE + + +proportional = IfcControllerTypeEnum.PROPORTIONAL + + +twoposition = IfcControllerTypeEnum.TWOPOSITION + + +userdefined = IfcControllerTypeEnum.USERDEFINED + + +notdefined = IfcControllerTypeEnum.NOTDEFINED + + +IfcConveyorSegmentTypeEnum = enum_namespace() + + +beltconveyor = IfcConveyorSegmentTypeEnum.BELTCONVEYOR + + +bucketconveyor = IfcConveyorSegmentTypeEnum.BUCKETCONVEYOR + + +chuteconveyor = IfcConveyorSegmentTypeEnum.CHUTECONVEYOR + + +screwconveyor = IfcConveyorSegmentTypeEnum.SCREWCONVEYOR + + +userdefined = IfcConveyorSegmentTypeEnum.USERDEFINED + + +notdefined = IfcConveyorSegmentTypeEnum.NOTDEFINED + + +IfcCooledBeamTypeEnum = enum_namespace() + + +active = IfcCooledBeamTypeEnum.ACTIVE + + +passive = IfcCooledBeamTypeEnum.PASSIVE + + +userdefined = IfcCooledBeamTypeEnum.USERDEFINED + + +notdefined = IfcCooledBeamTypeEnum.NOTDEFINED + + +IfcCoolingTowerTypeEnum = enum_namespace() + + +mechanicalforceddraft = IfcCoolingTowerTypeEnum.MECHANICALFORCEDDRAFT + + +mechanicalinduceddraft = IfcCoolingTowerTypeEnum.MECHANICALINDUCEDDRAFT + + +naturaldraft = IfcCoolingTowerTypeEnum.NATURALDRAFT + + +userdefined = IfcCoolingTowerTypeEnum.USERDEFINED + + +notdefined = IfcCoolingTowerTypeEnum.NOTDEFINED + + +IfcCostItemTypeEnum = enum_namespace() + + +userdefined = IfcCostItemTypeEnum.USERDEFINED + + +notdefined = IfcCostItemTypeEnum.NOTDEFINED + + +IfcCostScheduleTypeEnum = enum_namespace() + + +budget = IfcCostScheduleTypeEnum.BUDGET + + +costplan = IfcCostScheduleTypeEnum.COSTPLAN + + +estimate = IfcCostScheduleTypeEnum.ESTIMATE + + +pricedbillofquantities = IfcCostScheduleTypeEnum.PRICEDBILLOFQUANTITIES + + +scheduleofrates = IfcCostScheduleTypeEnum.SCHEDULEOFRATES + + +tender = IfcCostScheduleTypeEnum.TENDER + + +unpricedbillofquantities = IfcCostScheduleTypeEnum.UNPRICEDBILLOFQUANTITIES + + +userdefined = IfcCostScheduleTypeEnum.USERDEFINED + + +notdefined = IfcCostScheduleTypeEnum.NOTDEFINED + + +IfcCourseTypeEnum = enum_namespace() + + +armour = IfcCourseTypeEnum.ARMOUR + + +ballastbed = IfcCourseTypeEnum.BALLASTBED + + +core = IfcCourseTypeEnum.CORE + + +filter = IfcCourseTypeEnum.FILTER + + +pavement = IfcCourseTypeEnum.PAVEMENT + + +protection = IfcCourseTypeEnum.PROTECTION + + +userdefined = IfcCourseTypeEnum.USERDEFINED + + +notdefined = IfcCourseTypeEnum.NOTDEFINED + + +IfcCoveringTypeEnum = enum_namespace() + + +ceiling = IfcCoveringTypeEnum.CEILING + + +cladding = IfcCoveringTypeEnum.CLADDING + + +coping = IfcCoveringTypeEnum.COPING + + +flooring = IfcCoveringTypeEnum.FLOORING + + +insulation = IfcCoveringTypeEnum.INSULATION + + +membrane = IfcCoveringTypeEnum.MEMBRANE + + +molding = IfcCoveringTypeEnum.MOLDING + + +roofing = IfcCoveringTypeEnum.ROOFING + + +skirtingboard = IfcCoveringTypeEnum.SKIRTINGBOARD + + +sleeving = IfcCoveringTypeEnum.SLEEVING + + +topping = IfcCoveringTypeEnum.TOPPING + + +wrapping = IfcCoveringTypeEnum.WRAPPING + + +userdefined = IfcCoveringTypeEnum.USERDEFINED + + +notdefined = IfcCoveringTypeEnum.NOTDEFINED + + +IfcCrewResourceTypeEnum = enum_namespace() + + +office = IfcCrewResourceTypeEnum.OFFICE + + +site = IfcCrewResourceTypeEnum.SITE + + +userdefined = IfcCrewResourceTypeEnum.USERDEFINED + + +notdefined = IfcCrewResourceTypeEnum.NOTDEFINED + + +IfcCurtainWallTypeEnum = enum_namespace() + + +userdefined = IfcCurtainWallTypeEnum.USERDEFINED + + +notdefined = IfcCurtainWallTypeEnum.NOTDEFINED + + +IfcCurveInterpolationEnum = enum_namespace() + + +linear = IfcCurveInterpolationEnum.LINEAR + + +log_linear = IfcCurveInterpolationEnum.LOG_LINEAR + + +log_log = IfcCurveInterpolationEnum.LOG_LOG + + +notdefined = IfcCurveInterpolationEnum.NOTDEFINED + + +IfcDamperTypeEnum = enum_namespace() + + +backdraftdamper = IfcDamperTypeEnum.BACKDRAFTDAMPER + + +balancingdamper = IfcDamperTypeEnum.BALANCINGDAMPER + + +blastdamper = IfcDamperTypeEnum.BLASTDAMPER + + +controldamper = IfcDamperTypeEnum.CONTROLDAMPER + + +firedamper = IfcDamperTypeEnum.FIREDAMPER + + +firesmokedamper = IfcDamperTypeEnum.FIRESMOKEDAMPER + + +fumehoodexhaust = IfcDamperTypeEnum.FUMEHOODEXHAUST + + +gravitydamper = IfcDamperTypeEnum.GRAVITYDAMPER + + +gravityreliefdamper = IfcDamperTypeEnum.GRAVITYRELIEFDAMPER + + +reliefdamper = IfcDamperTypeEnum.RELIEFDAMPER + + +smokedamper = IfcDamperTypeEnum.SMOKEDAMPER + + +userdefined = IfcDamperTypeEnum.USERDEFINED + + +notdefined = IfcDamperTypeEnum.NOTDEFINED + + +IfcDataOriginEnum = enum_namespace() + + +measured = IfcDataOriginEnum.MEASURED + + +predicted = IfcDataOriginEnum.PREDICTED + + +simulated = IfcDataOriginEnum.SIMULATED + + +userdefined = IfcDataOriginEnum.USERDEFINED + + +notdefined = IfcDataOriginEnum.NOTDEFINED + + +IfcDerivedUnitEnum = enum_namespace() + + +accelerationunit = IfcDerivedUnitEnum.ACCELERATIONUNIT + + +angularvelocityunit = IfcDerivedUnitEnum.ANGULARVELOCITYUNIT + + +areadensityunit = IfcDerivedUnitEnum.AREADENSITYUNIT + + +compoundplaneangleunit = IfcDerivedUnitEnum.COMPOUNDPLANEANGLEUNIT + + +curvatureunit = IfcDerivedUnitEnum.CURVATUREUNIT + + +dynamicviscosityunit = IfcDerivedUnitEnum.DYNAMICVISCOSITYUNIT + + +heatfluxdensityunit = IfcDerivedUnitEnum.HEATFLUXDENSITYUNIT + + +heatingvalueunit = IfcDerivedUnitEnum.HEATINGVALUEUNIT + + +integercountrateunit = IfcDerivedUnitEnum.INTEGERCOUNTRATEUNIT + + +ionconcentrationunit = IfcDerivedUnitEnum.IONCONCENTRATIONUNIT + + +isothermalmoisturecapacityunit = IfcDerivedUnitEnum.ISOTHERMALMOISTURECAPACITYUNIT + + +kinematicviscosityunit = IfcDerivedUnitEnum.KINEMATICVISCOSITYUNIT + + +linearforceunit = IfcDerivedUnitEnum.LINEARFORCEUNIT + + +linearmomentunit = IfcDerivedUnitEnum.LINEARMOMENTUNIT + + +linearstiffnessunit = IfcDerivedUnitEnum.LINEARSTIFFNESSUNIT + + +linearvelocityunit = IfcDerivedUnitEnum.LINEARVELOCITYUNIT + + +luminousintensitydistributionunit = IfcDerivedUnitEnum.LUMINOUSINTENSITYDISTRIBUTIONUNIT + + +massdensityunit = IfcDerivedUnitEnum.MASSDENSITYUNIT + + +massflowrateunit = IfcDerivedUnitEnum.MASSFLOWRATEUNIT + + +massperlengthunit = IfcDerivedUnitEnum.MASSPERLENGTHUNIT + + +modulusofelasticityunit = IfcDerivedUnitEnum.MODULUSOFELASTICITYUNIT + + +modulusoflinearsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFLINEARSUBGRADEREACTIONUNIT + + +modulusofrotationalsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFROTATIONALSUBGRADEREACTIONUNIT + + +modulusofsubgradereactionunit = IfcDerivedUnitEnum.MODULUSOFSUBGRADEREACTIONUNIT + + +moisturediffusivityunit = IfcDerivedUnitEnum.MOISTUREDIFFUSIVITYUNIT + + +molecularweightunit = IfcDerivedUnitEnum.MOLECULARWEIGHTUNIT + + +momentofinertiaunit = IfcDerivedUnitEnum.MOMENTOFINERTIAUNIT + + +phunit = IfcDerivedUnitEnum.PHUNIT + + +planarforceunit = IfcDerivedUnitEnum.PLANARFORCEUNIT + + +rotationalfrequencyunit = IfcDerivedUnitEnum.ROTATIONALFREQUENCYUNIT + + +rotationalmassunit = IfcDerivedUnitEnum.ROTATIONALMASSUNIT + + +rotationalstiffnessunit = IfcDerivedUnitEnum.ROTATIONALSTIFFNESSUNIT + + +sectionareaintegralunit = IfcDerivedUnitEnum.SECTIONAREAINTEGRALUNIT + + +sectionmodulusunit = IfcDerivedUnitEnum.SECTIONMODULUSUNIT + + +shearmodulusunit = IfcDerivedUnitEnum.SHEARMODULUSUNIT + + +soundpowerlevelunit = IfcDerivedUnitEnum.SOUNDPOWERLEVELUNIT + + +soundpowerunit = IfcDerivedUnitEnum.SOUNDPOWERUNIT + + +soundpressurelevelunit = IfcDerivedUnitEnum.SOUNDPRESSURELEVELUNIT + + +soundpressureunit = IfcDerivedUnitEnum.SOUNDPRESSUREUNIT + + +specificheatcapacityunit = IfcDerivedUnitEnum.SPECIFICHEATCAPACITYUNIT + + +temperaturegradientunit = IfcDerivedUnitEnum.TEMPERATUREGRADIENTUNIT + + +temperaturerateofchangeunit = IfcDerivedUnitEnum.TEMPERATURERATEOFCHANGEUNIT + + +thermaladmittanceunit = IfcDerivedUnitEnum.THERMALADMITTANCEUNIT + + +thermalconductanceunit = IfcDerivedUnitEnum.THERMALCONDUCTANCEUNIT + + +thermalexpansioncoefficientunit = IfcDerivedUnitEnum.THERMALEXPANSIONCOEFFICIENTUNIT + + +thermalresistanceunit = IfcDerivedUnitEnum.THERMALRESISTANCEUNIT + + +thermaltransmittanceunit = IfcDerivedUnitEnum.THERMALTRANSMITTANCEUNIT + + +torqueunit = IfcDerivedUnitEnum.TORQUEUNIT + + +vaporpermeabilityunit = IfcDerivedUnitEnum.VAPORPERMEABILITYUNIT + + +volumetricflowrateunit = IfcDerivedUnitEnum.VOLUMETRICFLOWRATEUNIT + + +warpingconstantunit = IfcDerivedUnitEnum.WARPINGCONSTANTUNIT + + +warpingmomentunit = IfcDerivedUnitEnum.WARPINGMOMENTUNIT + + +userdefined = IfcDerivedUnitEnum.USERDEFINED + + +IfcDirectionSenseEnum = enum_namespace() + + +negative = IfcDirectionSenseEnum.NEGATIVE + + +positive = IfcDirectionSenseEnum.POSITIVE + + +IfcDiscreteAccessoryTypeEnum = enum_namespace() + + +anchorplate = IfcDiscreteAccessoryTypeEnum.ANCHORPLATE + + +birdprotection = IfcDiscreteAccessoryTypeEnum.BIRDPROTECTION + + +bracket = IfcDiscreteAccessoryTypeEnum.BRACKET + + +cablearranger = IfcDiscreteAccessoryTypeEnum.CABLEARRANGER + + +elastic_cushion = IfcDiscreteAccessoryTypeEnum.ELASTIC_CUSHION + + +expansion_joint_device = IfcDiscreteAccessoryTypeEnum.EXPANSION_JOINT_DEVICE + + +filler = IfcDiscreteAccessoryTypeEnum.FILLER + + +flashing = IfcDiscreteAccessoryTypeEnum.FLASHING + + +insulator = IfcDiscreteAccessoryTypeEnum.INSULATOR + + +lock = IfcDiscreteAccessoryTypeEnum.LOCK + + +panel_strengthening = IfcDiscreteAccessoryTypeEnum.PANEL_STRENGTHENING + + +pointmachinemountingdevice = IfcDiscreteAccessoryTypeEnum.POINTMACHINEMOUNTINGDEVICE + + +point_machine_locking_device = IfcDiscreteAccessoryTypeEnum.POINT_MACHINE_LOCKING_DEVICE + + +railbrace = IfcDiscreteAccessoryTypeEnum.RAILBRACE + + +railpad = IfcDiscreteAccessoryTypeEnum.RAILPAD + + +rail_lubrication = IfcDiscreteAccessoryTypeEnum.RAIL_LUBRICATION + + +rail_mechanical_equipment = IfcDiscreteAccessoryTypeEnum.RAIL_MECHANICAL_EQUIPMENT + + +shoe = IfcDiscreteAccessoryTypeEnum.SHOE + + +slidingchair = IfcDiscreteAccessoryTypeEnum.SLIDINGCHAIR + + +soundabsorption = IfcDiscreteAccessoryTypeEnum.SOUNDABSORPTION + + +tensioningequipment = IfcDiscreteAccessoryTypeEnum.TENSIONINGEQUIPMENT + + +userdefined = IfcDiscreteAccessoryTypeEnum.USERDEFINED + + +notdefined = IfcDiscreteAccessoryTypeEnum.NOTDEFINED + + +IfcDistributionBoardTypeEnum = enum_namespace() + + +consumerunit = IfcDistributionBoardTypeEnum.CONSUMERUNIT + + +dispatchingboard = IfcDistributionBoardTypeEnum.DISPATCHINGBOARD + + +distributionboard = IfcDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +distributionframe = IfcDistributionBoardTypeEnum.DISTRIBUTIONFRAME + + +motorcontrolcentre = IfcDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +switchboard = IfcDistributionBoardTypeEnum.SWITCHBOARD + + +userdefined = IfcDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcDistributionBoardTypeEnum.NOTDEFINED + + +IfcDistributionChamberElementTypeEnum = enum_namespace() + + +formedduct = IfcDistributionChamberElementTypeEnum.FORMEDDUCT + + +inspectionchamber = IfcDistributionChamberElementTypeEnum.INSPECTIONCHAMBER + + +inspectionpit = IfcDistributionChamberElementTypeEnum.INSPECTIONPIT + + +manhole = IfcDistributionChamberElementTypeEnum.MANHOLE + + +meterchamber = IfcDistributionChamberElementTypeEnum.METERCHAMBER + + +sump = IfcDistributionChamberElementTypeEnum.SUMP + + +trench = IfcDistributionChamberElementTypeEnum.TRENCH + + +valvechamber = IfcDistributionChamberElementTypeEnum.VALVECHAMBER + + +userdefined = IfcDistributionChamberElementTypeEnum.USERDEFINED + + +notdefined = IfcDistributionChamberElementTypeEnum.NOTDEFINED + + +IfcDistributionPortTypeEnum = enum_namespace() + + +cable = IfcDistributionPortTypeEnum.CABLE + + +cablecarrier = IfcDistributionPortTypeEnum.CABLECARRIER + + +duct = IfcDistributionPortTypeEnum.DUCT + + +pipe = IfcDistributionPortTypeEnum.PIPE + + +wireless = IfcDistributionPortTypeEnum.WIRELESS + + +userdefined = IfcDistributionPortTypeEnum.USERDEFINED + + +notdefined = IfcDistributionPortTypeEnum.NOTDEFINED + + +IfcDistributionSystemEnum = enum_namespace() + + +airconditioning = IfcDistributionSystemEnum.AIRCONDITIONING + + +audiovisual = IfcDistributionSystemEnum.AUDIOVISUAL + + +catenary_system = IfcDistributionSystemEnum.CATENARY_SYSTEM + + +chemical = IfcDistributionSystemEnum.CHEMICAL + + +chilledwater = IfcDistributionSystemEnum.CHILLEDWATER + + +communication = IfcDistributionSystemEnum.COMMUNICATION + + +compressedair = IfcDistributionSystemEnum.COMPRESSEDAIR + + +condenserwater = IfcDistributionSystemEnum.CONDENSERWATER + + +control = IfcDistributionSystemEnum.CONTROL + + +conveying = IfcDistributionSystemEnum.CONVEYING + + +data = IfcDistributionSystemEnum.DATA + + +disposal = IfcDistributionSystemEnum.DISPOSAL + + +domesticcoldwater = IfcDistributionSystemEnum.DOMESTICCOLDWATER + + +domestichotwater = IfcDistributionSystemEnum.DOMESTICHOTWATER + + +drainage = IfcDistributionSystemEnum.DRAINAGE + + +earthing = IfcDistributionSystemEnum.EARTHING + + +electrical = IfcDistributionSystemEnum.ELECTRICAL + + +electroacoustic = IfcDistributionSystemEnum.ELECTROACOUSTIC + + +exhaust = IfcDistributionSystemEnum.EXHAUST + + +fireprotection = IfcDistributionSystemEnum.FIREPROTECTION + + +fixedtransmissionnetwork = IfcDistributionSystemEnum.FIXEDTRANSMISSIONNETWORK + + +fuel = IfcDistributionSystemEnum.FUEL + + +gas = IfcDistributionSystemEnum.GAS + + +hazardous = IfcDistributionSystemEnum.HAZARDOUS + + +heating = IfcDistributionSystemEnum.HEATING + + +lighting = IfcDistributionSystemEnum.LIGHTING + + +lightningprotection = IfcDistributionSystemEnum.LIGHTNINGPROTECTION + + +mobilenetwork = IfcDistributionSystemEnum.MOBILENETWORK + + +monitoringsystem = IfcDistributionSystemEnum.MONITORINGSYSTEM + + +municipalsolidwaste = IfcDistributionSystemEnum.MUNICIPALSOLIDWASTE + + +oil = IfcDistributionSystemEnum.OIL + + +operational = IfcDistributionSystemEnum.OPERATIONAL + + +operationaltelephonysystem = IfcDistributionSystemEnum.OPERATIONALTELEPHONYSYSTEM + + +overhead_contactline_system = IfcDistributionSystemEnum.OVERHEAD_CONTACTLINE_SYSTEM + + +powergeneration = IfcDistributionSystemEnum.POWERGENERATION + + +rainwater = IfcDistributionSystemEnum.RAINWATER + + +refrigeration = IfcDistributionSystemEnum.REFRIGERATION + + +return_circuit = IfcDistributionSystemEnum.RETURN_CIRCUIT + + +security = IfcDistributionSystemEnum.SECURITY + + +sewage = IfcDistributionSystemEnum.SEWAGE + + +signal = IfcDistributionSystemEnum.SIGNAL + + +stormwater = IfcDistributionSystemEnum.STORMWATER + + +telephone = IfcDistributionSystemEnum.TELEPHONE + + +tv = IfcDistributionSystemEnum.TV + + +vacuum = IfcDistributionSystemEnum.VACUUM + + +vent = IfcDistributionSystemEnum.VENT + + +ventilation = IfcDistributionSystemEnum.VENTILATION + + +wastewater = IfcDistributionSystemEnum.WASTEWATER + + +watersupply = IfcDistributionSystemEnum.WATERSUPPLY + + +userdefined = IfcDistributionSystemEnum.USERDEFINED + + +notdefined = IfcDistributionSystemEnum.NOTDEFINED + + +IfcDocumentConfidentialityEnum = enum_namespace() + + +confidential = IfcDocumentConfidentialityEnum.CONFIDENTIAL + + +personal = IfcDocumentConfidentialityEnum.PERSONAL + + +public = IfcDocumentConfidentialityEnum.PUBLIC + + +restricted = IfcDocumentConfidentialityEnum.RESTRICTED + + +userdefined = IfcDocumentConfidentialityEnum.USERDEFINED + + +notdefined = IfcDocumentConfidentialityEnum.NOTDEFINED + + +IfcDocumentStatusEnum = enum_namespace() + + +draft = IfcDocumentStatusEnum.DRAFT + + +final = IfcDocumentStatusEnum.FINAL + + +finaldraft = IfcDocumentStatusEnum.FINALDRAFT + + +revision = IfcDocumentStatusEnum.REVISION + + +notdefined = IfcDocumentStatusEnum.NOTDEFINED + + +IfcDoorPanelOperationEnum = enum_namespace() + + +double_acting = IfcDoorPanelOperationEnum.DOUBLE_ACTING + + +fixedpanel = IfcDoorPanelOperationEnum.FIXEDPANEL + + +folding = IfcDoorPanelOperationEnum.FOLDING + + +revolving = IfcDoorPanelOperationEnum.REVOLVING + + +rollingup = IfcDoorPanelOperationEnum.ROLLINGUP + + +sliding = IfcDoorPanelOperationEnum.SLIDING + + +swinging = IfcDoorPanelOperationEnum.SWINGING + + +userdefined = IfcDoorPanelOperationEnum.USERDEFINED + + +notdefined = IfcDoorPanelOperationEnum.NOTDEFINED + + +IfcDoorPanelPositionEnum = enum_namespace() + + +left = IfcDoorPanelPositionEnum.LEFT + + +middle = IfcDoorPanelPositionEnum.MIDDLE + + +right = IfcDoorPanelPositionEnum.RIGHT + + +notdefined = IfcDoorPanelPositionEnum.NOTDEFINED + + +IfcDoorTypeEnum = enum_namespace() + + +boom_barrier = IfcDoorTypeEnum.BOOM_BARRIER + + +door = IfcDoorTypeEnum.DOOR + + +gate = IfcDoorTypeEnum.GATE + + +trapdoor = IfcDoorTypeEnum.TRAPDOOR + + +turnstile = IfcDoorTypeEnum.TURNSTILE + + +userdefined = IfcDoorTypeEnum.USERDEFINED + + +notdefined = IfcDoorTypeEnum.NOTDEFINED + + +IfcDoorTypeOperationEnum = enum_namespace() + + +double_door_double_swing = IfcDoorTypeOperationEnum.DOUBLE_DOOR_DOUBLE_SWING + + +double_door_folding = IfcDoorTypeOperationEnum.DOUBLE_DOOR_FOLDING + + +double_door_lifting_vertical = IfcDoorTypeOperationEnum.DOUBLE_DOOR_LIFTING_VERTICAL + + +double_door_single_swing = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING + + +double_door_single_swing_opposite_left = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT + + +double_door_single_swing_opposite_right = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT + + +double_door_sliding = IfcDoorTypeOperationEnum.DOUBLE_DOOR_SLIDING + + +double_swing_left = IfcDoorTypeOperationEnum.DOUBLE_SWING_LEFT + + +double_swing_right = IfcDoorTypeOperationEnum.DOUBLE_SWING_RIGHT + + +folding_to_left = IfcDoorTypeOperationEnum.FOLDING_TO_LEFT + + +folding_to_right = IfcDoorTypeOperationEnum.FOLDING_TO_RIGHT + + +lifting_horizontal = IfcDoorTypeOperationEnum.LIFTING_HORIZONTAL + + +lifting_vertical_left = IfcDoorTypeOperationEnum.LIFTING_VERTICAL_LEFT + + +lifting_vertical_right = IfcDoorTypeOperationEnum.LIFTING_VERTICAL_RIGHT + + +revolving = IfcDoorTypeOperationEnum.REVOLVING + + +revolving_vertical = IfcDoorTypeOperationEnum.REVOLVING_VERTICAL + + +rollingup = IfcDoorTypeOperationEnum.ROLLINGUP + + +single_swing_left = IfcDoorTypeOperationEnum.SINGLE_SWING_LEFT + + +single_swing_right = IfcDoorTypeOperationEnum.SINGLE_SWING_RIGHT + + +sliding_to_left = IfcDoorTypeOperationEnum.SLIDING_TO_LEFT + + +sliding_to_right = IfcDoorTypeOperationEnum.SLIDING_TO_RIGHT + + +swing_fixed_left = IfcDoorTypeOperationEnum.SWING_FIXED_LEFT + + +swing_fixed_right = IfcDoorTypeOperationEnum.SWING_FIXED_RIGHT + + +userdefined = IfcDoorTypeOperationEnum.USERDEFINED + + +notdefined = IfcDoorTypeOperationEnum.NOTDEFINED + + +IfcDuctFittingTypeEnum = enum_namespace() + + +bend = IfcDuctFittingTypeEnum.BEND + + +connector = IfcDuctFittingTypeEnum.CONNECTOR + + +entry = IfcDuctFittingTypeEnum.ENTRY + + +exit = IfcDuctFittingTypeEnum.EXIT + + +junction = IfcDuctFittingTypeEnum.JUNCTION + + +obstruction = IfcDuctFittingTypeEnum.OBSTRUCTION + + +transition = IfcDuctFittingTypeEnum.TRANSITION + + +userdefined = IfcDuctFittingTypeEnum.USERDEFINED + + +notdefined = IfcDuctFittingTypeEnum.NOTDEFINED + + +IfcDuctSegmentTypeEnum = enum_namespace() + + +flexiblesegment = IfcDuctSegmentTypeEnum.FLEXIBLESEGMENT + + +rigidsegment = IfcDuctSegmentTypeEnum.RIGIDSEGMENT + + +userdefined = IfcDuctSegmentTypeEnum.USERDEFINED + + +notdefined = IfcDuctSegmentTypeEnum.NOTDEFINED + + +IfcDuctSilencerTypeEnum = enum_namespace() + + +flatoval = IfcDuctSilencerTypeEnum.FLATOVAL + + +rectangular = IfcDuctSilencerTypeEnum.RECTANGULAR + + +round = IfcDuctSilencerTypeEnum.ROUND + + +userdefined = IfcDuctSilencerTypeEnum.USERDEFINED + + +notdefined = IfcDuctSilencerTypeEnum.NOTDEFINED + + +IfcEarthworksCutTypeEnum = enum_namespace() + + +base_excavation = IfcEarthworksCutTypeEnum.BASE_EXCAVATION + + +cut = IfcEarthworksCutTypeEnum.CUT + + +dredging = IfcEarthworksCutTypeEnum.DREDGING + + +excavation = IfcEarthworksCutTypeEnum.EXCAVATION + + +overexcavation = IfcEarthworksCutTypeEnum.OVEREXCAVATION + + +pavementmilling = IfcEarthworksCutTypeEnum.PAVEMENTMILLING + + +stepexcavation = IfcEarthworksCutTypeEnum.STEPEXCAVATION + + +topsoilremoval = IfcEarthworksCutTypeEnum.TOPSOILREMOVAL + + +trench = IfcEarthworksCutTypeEnum.TRENCH + + +userdefined = IfcEarthworksCutTypeEnum.USERDEFINED + + +notdefined = IfcEarthworksCutTypeEnum.NOTDEFINED + + +IfcEarthworksFillTypeEnum = enum_namespace() + + +backfill = IfcEarthworksFillTypeEnum.BACKFILL + + +counterweight = IfcEarthworksFillTypeEnum.COUNTERWEIGHT + + +embankment = IfcEarthworksFillTypeEnum.EMBANKMENT + + +slopefill = IfcEarthworksFillTypeEnum.SLOPEFILL + + +subgrade = IfcEarthworksFillTypeEnum.SUBGRADE + + +subgradebed = IfcEarthworksFillTypeEnum.SUBGRADEBED + + +transitionsection = IfcEarthworksFillTypeEnum.TRANSITIONSECTION + + +userdefined = IfcEarthworksFillTypeEnum.USERDEFINED + + +notdefined = IfcEarthworksFillTypeEnum.NOTDEFINED + + +IfcElectricApplianceTypeEnum = enum_namespace() + + +dishwasher = IfcElectricApplianceTypeEnum.DISHWASHER + + +electriccooker = IfcElectricApplianceTypeEnum.ELECTRICCOOKER + + +freestandingelectricheater = IfcElectricApplianceTypeEnum.FREESTANDINGELECTRICHEATER + + +freestandingfan = IfcElectricApplianceTypeEnum.FREESTANDINGFAN + + +freestandingwatercooler = IfcElectricApplianceTypeEnum.FREESTANDINGWATERCOOLER + + +freestandingwaterheater = IfcElectricApplianceTypeEnum.FREESTANDINGWATERHEATER + + +freezer = IfcElectricApplianceTypeEnum.FREEZER + + +fridge_freezer = IfcElectricApplianceTypeEnum.FRIDGE_FREEZER + + +handdryer = IfcElectricApplianceTypeEnum.HANDDRYER + + +kitchenmachine = IfcElectricApplianceTypeEnum.KITCHENMACHINE + + +microwave = IfcElectricApplianceTypeEnum.MICROWAVE + + +photocopier = IfcElectricApplianceTypeEnum.PHOTOCOPIER + + +refrigerator = IfcElectricApplianceTypeEnum.REFRIGERATOR + + +tumbledryer = IfcElectricApplianceTypeEnum.TUMBLEDRYER + + +vendingmachine = IfcElectricApplianceTypeEnum.VENDINGMACHINE + + +washingmachine = IfcElectricApplianceTypeEnum.WASHINGMACHINE + + +userdefined = IfcElectricApplianceTypeEnum.USERDEFINED + + +notdefined = IfcElectricApplianceTypeEnum.NOTDEFINED + + +IfcElectricDistributionBoardTypeEnum = enum_namespace() + + +consumerunit = IfcElectricDistributionBoardTypeEnum.CONSUMERUNIT + + +distributionboard = IfcElectricDistributionBoardTypeEnum.DISTRIBUTIONBOARD + + +motorcontrolcentre = IfcElectricDistributionBoardTypeEnum.MOTORCONTROLCENTRE + + +switchboard = IfcElectricDistributionBoardTypeEnum.SWITCHBOARD + + +userdefined = IfcElectricDistributionBoardTypeEnum.USERDEFINED + + +notdefined = IfcElectricDistributionBoardTypeEnum.NOTDEFINED + + +IfcElectricFlowStorageDeviceTypeEnum = enum_namespace() + + +battery = IfcElectricFlowStorageDeviceTypeEnum.BATTERY + + +capacitor = IfcElectricFlowStorageDeviceTypeEnum.CAPACITOR + + +capacitorbank = IfcElectricFlowStorageDeviceTypeEnum.CAPACITORBANK + + +compensator = IfcElectricFlowStorageDeviceTypeEnum.COMPENSATOR + + +harmonicfilter = IfcElectricFlowStorageDeviceTypeEnum.HARMONICFILTER + + +inductor = IfcElectricFlowStorageDeviceTypeEnum.INDUCTOR + + +inductorbank = IfcElectricFlowStorageDeviceTypeEnum.INDUCTORBANK + + +recharger = IfcElectricFlowStorageDeviceTypeEnum.RECHARGER + + +ups = IfcElectricFlowStorageDeviceTypeEnum.UPS + + +userdefined = IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowStorageDeviceTypeEnum.NOTDEFINED + + +IfcElectricFlowTreatmentDeviceTypeEnum = enum_namespace() + + +electronicfilter = IfcElectricFlowTreatmentDeviceTypeEnum.ELECTRONICFILTER + + +userdefined = IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED + + +notdefined = IfcElectricFlowTreatmentDeviceTypeEnum.NOTDEFINED + + +IfcElectricGeneratorTypeEnum = enum_namespace() + + +chp = IfcElectricGeneratorTypeEnum.CHP + + +enginegenerator = IfcElectricGeneratorTypeEnum.ENGINEGENERATOR + + +standalone = IfcElectricGeneratorTypeEnum.STANDALONE + + +userdefined = IfcElectricGeneratorTypeEnum.USERDEFINED + + +notdefined = IfcElectricGeneratorTypeEnum.NOTDEFINED + + +IfcElectricMotorTypeEnum = enum_namespace() + + +dc = IfcElectricMotorTypeEnum.DC + + +induction = IfcElectricMotorTypeEnum.INDUCTION + + +polyphase = IfcElectricMotorTypeEnum.POLYPHASE + + +reluctancesynchronous = IfcElectricMotorTypeEnum.RELUCTANCESYNCHRONOUS + + +synchronous = IfcElectricMotorTypeEnum.SYNCHRONOUS + + +userdefined = IfcElectricMotorTypeEnum.USERDEFINED + + +notdefined = IfcElectricMotorTypeEnum.NOTDEFINED + + +IfcElectricTimeControlTypeEnum = enum_namespace() + + +relay = IfcElectricTimeControlTypeEnum.RELAY + + +timeclock = IfcElectricTimeControlTypeEnum.TIMECLOCK + + +timedelay = IfcElectricTimeControlTypeEnum.TIMEDELAY + + +userdefined = IfcElectricTimeControlTypeEnum.USERDEFINED + + +notdefined = IfcElectricTimeControlTypeEnum.NOTDEFINED + + +IfcElementAssemblyTypeEnum = enum_namespace() + + +abutment = IfcElementAssemblyTypeEnum.ABUTMENT + + +accessory_assembly = IfcElementAssemblyTypeEnum.ACCESSORY_ASSEMBLY + + +arch = IfcElementAssemblyTypeEnum.ARCH + + +beam_grid = IfcElementAssemblyTypeEnum.BEAM_GRID + + +braced_frame = IfcElementAssemblyTypeEnum.BRACED_FRAME + + +cross_bracing = IfcElementAssemblyTypeEnum.CROSS_BRACING + + +deck = IfcElementAssemblyTypeEnum.DECK + + +dilatationpanel = IfcElementAssemblyTypeEnum.DILATATIONPANEL + + +entranceworks = IfcElementAssemblyTypeEnum.ENTRANCEWORKS + + +girder = IfcElementAssemblyTypeEnum.GIRDER + + +grid = IfcElementAssemblyTypeEnum.GRID + + +mast = IfcElementAssemblyTypeEnum.MAST + + +pier = IfcElementAssemblyTypeEnum.PIER + + +pylon = IfcElementAssemblyTypeEnum.PYLON + + +rail_mechanical_equipment_assembly = IfcElementAssemblyTypeEnum.RAIL_MECHANICAL_EQUIPMENT_ASSEMBLY + + +reinforcement_unit = IfcElementAssemblyTypeEnum.REINFORCEMENT_UNIT + + +rigid_frame = IfcElementAssemblyTypeEnum.RIGID_FRAME + + +shelter = IfcElementAssemblyTypeEnum.SHELTER + + +signalassembly = IfcElementAssemblyTypeEnum.SIGNALASSEMBLY + + +slab_field = IfcElementAssemblyTypeEnum.SLAB_FIELD + + +sumpbuster = IfcElementAssemblyTypeEnum.SUMPBUSTER + + +supportingassembly = IfcElementAssemblyTypeEnum.SUPPORTINGASSEMBLY + + +suspensionassembly = IfcElementAssemblyTypeEnum.SUSPENSIONASSEMBLY + + +trackpanel = IfcElementAssemblyTypeEnum.TRACKPANEL + + +traction_switching_assembly = IfcElementAssemblyTypeEnum.TRACTION_SWITCHING_ASSEMBLY + + +traffic_calming_device = IfcElementAssemblyTypeEnum.TRAFFIC_CALMING_DEVICE + + +truss = IfcElementAssemblyTypeEnum.TRUSS + + +turnoutpanel = IfcElementAssemblyTypeEnum.TURNOUTPANEL + + +userdefined = IfcElementAssemblyTypeEnum.USERDEFINED + + +notdefined = IfcElementAssemblyTypeEnum.NOTDEFINED + + +IfcElementCompositionEnum = enum_namespace() + + +complex = IfcElementCompositionEnum.COMPLEX + + +element = IfcElementCompositionEnum.ELEMENT + + +partial = IfcElementCompositionEnum.PARTIAL + + +IfcEngineTypeEnum = enum_namespace() + + +externalcombustion = IfcEngineTypeEnum.EXTERNALCOMBUSTION + + +internalcombustion = IfcEngineTypeEnum.INTERNALCOMBUSTION + + +userdefined = IfcEngineTypeEnum.USERDEFINED + + +notdefined = IfcEngineTypeEnum.NOTDEFINED + + +IfcEvaporativeCoolerTypeEnum = enum_namespace() + + +directevaporativeairwasher = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEAIRWASHER + + +directevaporativepackagedrotaryaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER + + +directevaporativerandommediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER + + +directevaporativerigidmediaaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER + + +directevaporativeslingerspackagedaircooler = IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER + + +indirectdirectcombination = IfcEvaporativeCoolerTypeEnum.INDIRECTDIRECTCOMBINATION + + +indirectevaporativecoolingtowerorcoilcooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER + + +indirectevaporativepackageaircooler = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEPACKAGEAIRCOOLER + + +indirectevaporativewetcoil = IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEWETCOIL + + +userdefined = IfcEvaporativeCoolerTypeEnum.USERDEFINED + + +notdefined = IfcEvaporativeCoolerTypeEnum.NOTDEFINED + + +IfcEvaporatorTypeEnum = enum_namespace() + + +directexpansion = IfcEvaporatorTypeEnum.DIRECTEXPANSION + + +directexpansionbrazedplate = IfcEvaporatorTypeEnum.DIRECTEXPANSIONBRAZEDPLATE + + +directexpansionshellandtube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONSHELLANDTUBE + + +directexpansiontubeintube = IfcEvaporatorTypeEnum.DIRECTEXPANSIONTUBEINTUBE + + +floodedshellandtube = IfcEvaporatorTypeEnum.FLOODEDSHELLANDTUBE + + +shellandcoil = IfcEvaporatorTypeEnum.SHELLANDCOIL + + +userdefined = IfcEvaporatorTypeEnum.USERDEFINED + + +notdefined = IfcEvaporatorTypeEnum.NOTDEFINED + + +IfcEventTriggerTypeEnum = enum_namespace() + + +eventcomplex = IfcEventTriggerTypeEnum.EVENTCOMPLEX + + +eventmessage = IfcEventTriggerTypeEnum.EVENTMESSAGE + + +eventrule = IfcEventTriggerTypeEnum.EVENTRULE + + +eventtime = IfcEventTriggerTypeEnum.EVENTTIME + + +userdefined = IfcEventTriggerTypeEnum.USERDEFINED + + +notdefined = IfcEventTriggerTypeEnum.NOTDEFINED + + +IfcEventTypeEnum = enum_namespace() + + +endevent = IfcEventTypeEnum.ENDEVENT + + +intermediateevent = IfcEventTypeEnum.INTERMEDIATEEVENT + + +startevent = IfcEventTypeEnum.STARTEVENT + + +userdefined = IfcEventTypeEnum.USERDEFINED + + +notdefined = IfcEventTypeEnum.NOTDEFINED + + +IfcExternalSpatialElementTypeEnum = enum_namespace() + + +external = IfcExternalSpatialElementTypeEnum.EXTERNAL + + +external_earth = IfcExternalSpatialElementTypeEnum.EXTERNAL_EARTH + + +external_fire = IfcExternalSpatialElementTypeEnum.EXTERNAL_FIRE + + +external_water = IfcExternalSpatialElementTypeEnum.EXTERNAL_WATER + + +userdefined = IfcExternalSpatialElementTypeEnum.USERDEFINED + + +notdefined = IfcExternalSpatialElementTypeEnum.NOTDEFINED + + +IfcFacilityPartCommonTypeEnum = enum_namespace() + + +aboveground = IfcFacilityPartCommonTypeEnum.ABOVEGROUND + + +belowground = IfcFacilityPartCommonTypeEnum.BELOWGROUND + + +junction = IfcFacilityPartCommonTypeEnum.JUNCTION + + +levelcrossing = IfcFacilityPartCommonTypeEnum.LEVELCROSSING + + +segment = IfcFacilityPartCommonTypeEnum.SEGMENT + + +substructure = IfcFacilityPartCommonTypeEnum.SUBSTRUCTURE + + +superstructure = IfcFacilityPartCommonTypeEnum.SUPERSTRUCTURE + + +terminal = IfcFacilityPartCommonTypeEnum.TERMINAL + + +userdefined = IfcFacilityPartCommonTypeEnum.USERDEFINED + + +notdefined = IfcFacilityPartCommonTypeEnum.NOTDEFINED + + +IfcFacilityUsageEnum = enum_namespace() + + +lateral = IfcFacilityUsageEnum.LATERAL + + +longitudinal = IfcFacilityUsageEnum.LONGITUDINAL + + +region = IfcFacilityUsageEnum.REGION + + +vertical = IfcFacilityUsageEnum.VERTICAL + + +userdefined = IfcFacilityUsageEnum.USERDEFINED + + +notdefined = IfcFacilityUsageEnum.NOTDEFINED + + +IfcFanTypeEnum = enum_namespace() + + +centrifugalairfoil = IfcFanTypeEnum.CENTRIFUGALAIRFOIL + + +centrifugalbackwardinclinedcurved = IfcFanTypeEnum.CENTRIFUGALBACKWARDINCLINEDCURVED + + +centrifugalforwardcurved = IfcFanTypeEnum.CENTRIFUGALFORWARDCURVED + + +centrifugalradial = IfcFanTypeEnum.CENTRIFUGALRADIAL + + +propelloraxial = IfcFanTypeEnum.PROPELLORAXIAL + + +tubeaxial = IfcFanTypeEnum.TUBEAXIAL + + +vaneaxial = IfcFanTypeEnum.VANEAXIAL + + +userdefined = IfcFanTypeEnum.USERDEFINED + + +notdefined = IfcFanTypeEnum.NOTDEFINED + + +IfcFastenerTypeEnum = enum_namespace() + + +glue = IfcFastenerTypeEnum.GLUE + + +mortar = IfcFastenerTypeEnum.MORTAR + + +weld = IfcFastenerTypeEnum.WELD + + +userdefined = IfcFastenerTypeEnum.USERDEFINED + + +notdefined = IfcFastenerTypeEnum.NOTDEFINED + + +IfcFilterTypeEnum = enum_namespace() + + +airparticlefilter = IfcFilterTypeEnum.AIRPARTICLEFILTER + + +compressedairfilter = IfcFilterTypeEnum.COMPRESSEDAIRFILTER + + +odorfilter = IfcFilterTypeEnum.ODORFILTER + + +oilfilter = IfcFilterTypeEnum.OILFILTER + + +strainer = IfcFilterTypeEnum.STRAINER + + +waterfilter = IfcFilterTypeEnum.WATERFILTER + + +userdefined = IfcFilterTypeEnum.USERDEFINED + + +notdefined = IfcFilterTypeEnum.NOTDEFINED + + +IfcFireSuppressionTerminalTypeEnum = enum_namespace() + + +breechinginlet = IfcFireSuppressionTerminalTypeEnum.BREECHINGINLET + + +firehydrant = IfcFireSuppressionTerminalTypeEnum.FIREHYDRANT + + +firemonitor = IfcFireSuppressionTerminalTypeEnum.FIREMONITOR + + +hosereel = IfcFireSuppressionTerminalTypeEnum.HOSEREEL + + +sprinkler = IfcFireSuppressionTerminalTypeEnum.SPRINKLER + + +sprinklerdeflector = IfcFireSuppressionTerminalTypeEnum.SPRINKLERDEFLECTOR + + +userdefined = IfcFireSuppressionTerminalTypeEnum.USERDEFINED + + +notdefined = IfcFireSuppressionTerminalTypeEnum.NOTDEFINED + + +IfcFlowDirectionEnum = enum_namespace() + + +sink = IfcFlowDirectionEnum.SINK + + +source = IfcFlowDirectionEnum.SOURCE + + +sourceandsink = IfcFlowDirectionEnum.SOURCEANDSINK + + +notdefined = IfcFlowDirectionEnum.NOTDEFINED + + +IfcFlowInstrumentTypeEnum = enum_namespace() + + +ammeter = IfcFlowInstrumentTypeEnum.AMMETER + + +combined = IfcFlowInstrumentTypeEnum.COMBINED + + +frequencymeter = IfcFlowInstrumentTypeEnum.FREQUENCYMETER + + +phaseanglemeter = IfcFlowInstrumentTypeEnum.PHASEANGLEMETER + + +powerfactormeter = IfcFlowInstrumentTypeEnum.POWERFACTORMETER + + +pressuregauge = IfcFlowInstrumentTypeEnum.PRESSUREGAUGE + + +thermometer = IfcFlowInstrumentTypeEnum.THERMOMETER + + +voltmeter = IfcFlowInstrumentTypeEnum.VOLTMETER + + +voltmeter_peak = IfcFlowInstrumentTypeEnum.VOLTMETER_PEAK + + +voltmeter_rms = IfcFlowInstrumentTypeEnum.VOLTMETER_RMS + + +userdefined = IfcFlowInstrumentTypeEnum.USERDEFINED + + +notdefined = IfcFlowInstrumentTypeEnum.NOTDEFINED + + +IfcFlowMeterTypeEnum = enum_namespace() + + +energymeter = IfcFlowMeterTypeEnum.ENERGYMETER + + +gasmeter = IfcFlowMeterTypeEnum.GASMETER + + +oilmeter = IfcFlowMeterTypeEnum.OILMETER + + +watermeter = IfcFlowMeterTypeEnum.WATERMETER + + +userdefined = IfcFlowMeterTypeEnum.USERDEFINED + + +notdefined = IfcFlowMeterTypeEnum.NOTDEFINED + + +IfcFootingTypeEnum = enum_namespace() + + +caisson_foundation = IfcFootingTypeEnum.CAISSON_FOUNDATION + + +footing_beam = IfcFootingTypeEnum.FOOTING_BEAM + + +pad_footing = IfcFootingTypeEnum.PAD_FOOTING + + +pile_cap = IfcFootingTypeEnum.PILE_CAP + + +strip_footing = IfcFootingTypeEnum.STRIP_FOOTING + + +userdefined = IfcFootingTypeEnum.USERDEFINED + + +notdefined = IfcFootingTypeEnum.NOTDEFINED + + +IfcFurnitureTypeEnum = enum_namespace() + + +bed = IfcFurnitureTypeEnum.BED + + +chair = IfcFurnitureTypeEnum.CHAIR + + +desk = IfcFurnitureTypeEnum.DESK + + +filecabinet = IfcFurnitureTypeEnum.FILECABINET + + +shelf = IfcFurnitureTypeEnum.SHELF + + +sofa = IfcFurnitureTypeEnum.SOFA + + +table = IfcFurnitureTypeEnum.TABLE + + +technicalcabinet = IfcFurnitureTypeEnum.TECHNICALCABINET + + +userdefined = IfcFurnitureTypeEnum.USERDEFINED + + +notdefined = IfcFurnitureTypeEnum.NOTDEFINED + + +IfcGeographicElementTypeEnum = enum_namespace() + + +soil_boring_point = IfcGeographicElementTypeEnum.SOIL_BORING_POINT + + +terrain = IfcGeographicElementTypeEnum.TERRAIN + + +vegetation = IfcGeographicElementTypeEnum.VEGETATION + + +userdefined = IfcGeographicElementTypeEnum.USERDEFINED + + +notdefined = IfcGeographicElementTypeEnum.NOTDEFINED + + +IfcGeometricProjectionEnum = enum_namespace() + + +elevation_view = IfcGeometricProjectionEnum.ELEVATION_VIEW + + +graph_view = IfcGeometricProjectionEnum.GRAPH_VIEW + + +model_view = IfcGeometricProjectionEnum.MODEL_VIEW + + +plan_view = IfcGeometricProjectionEnum.PLAN_VIEW + + +reflected_plan_view = IfcGeometricProjectionEnum.REFLECTED_PLAN_VIEW + + +section_view = IfcGeometricProjectionEnum.SECTION_VIEW + + +sketch_view = IfcGeometricProjectionEnum.SKETCH_VIEW + + +userdefined = IfcGeometricProjectionEnum.USERDEFINED + + +notdefined = IfcGeometricProjectionEnum.NOTDEFINED + + +IfcGeotechnicalStratumTypeEnum = enum_namespace() + + +solid = IfcGeotechnicalStratumTypeEnum.SOLID + + +void = IfcGeotechnicalStratumTypeEnum.VOID + + +water = IfcGeotechnicalStratumTypeEnum.WATER + + +userdefined = IfcGeotechnicalStratumTypeEnum.USERDEFINED + + +notdefined = IfcGeotechnicalStratumTypeEnum.NOTDEFINED + + +IfcGlobalOrLocalEnum = enum_namespace() + + +global_coords = IfcGlobalOrLocalEnum.GLOBAL_COORDS + + +local_coords = IfcGlobalOrLocalEnum.LOCAL_COORDS + + +IfcGridTypeEnum = enum_namespace() + + +irregular = IfcGridTypeEnum.IRREGULAR + + +radial = IfcGridTypeEnum.RADIAL + + +rectangular = IfcGridTypeEnum.RECTANGULAR + + +triangular = IfcGridTypeEnum.TRIANGULAR + + +userdefined = IfcGridTypeEnum.USERDEFINED + + +notdefined = IfcGridTypeEnum.NOTDEFINED + + +IfcHeatExchangerTypeEnum = enum_namespace() + + +plate = IfcHeatExchangerTypeEnum.PLATE + + +shellandtube = IfcHeatExchangerTypeEnum.SHELLANDTUBE + + +turnoutheating = IfcHeatExchangerTypeEnum.TURNOUTHEATING + + +userdefined = IfcHeatExchangerTypeEnum.USERDEFINED + + +notdefined = IfcHeatExchangerTypeEnum.NOTDEFINED + + +IfcHumidifierTypeEnum = enum_namespace() + + +adiabaticairwasher = IfcHumidifierTypeEnum.ADIABATICAIRWASHER + + +adiabaticatomizing = IfcHumidifierTypeEnum.ADIABATICATOMIZING + + +adiabaticcompressedairnozzle = IfcHumidifierTypeEnum.ADIABATICCOMPRESSEDAIRNOZZLE + + +adiabaticpan = IfcHumidifierTypeEnum.ADIABATICPAN + + +adiabaticrigidmedia = IfcHumidifierTypeEnum.ADIABATICRIGIDMEDIA + + +adiabaticultrasonic = IfcHumidifierTypeEnum.ADIABATICULTRASONIC + + +adiabaticwettedelement = IfcHumidifierTypeEnum.ADIABATICWETTEDELEMENT + + +assistedbutane = IfcHumidifierTypeEnum.ASSISTEDBUTANE + + +assistedelectric = IfcHumidifierTypeEnum.ASSISTEDELECTRIC + + +assistednaturalgas = IfcHumidifierTypeEnum.ASSISTEDNATURALGAS + + +assistedpropane = IfcHumidifierTypeEnum.ASSISTEDPROPANE + + +assistedsteam = IfcHumidifierTypeEnum.ASSISTEDSTEAM + + +steaminjection = IfcHumidifierTypeEnum.STEAMINJECTION + + +userdefined = IfcHumidifierTypeEnum.USERDEFINED + + +notdefined = IfcHumidifierTypeEnum.NOTDEFINED + + +IfcImpactProtectionDeviceTypeEnum = enum_namespace() + + +bumper = IfcImpactProtectionDeviceTypeEnum.BUMPER + + +crashcushion = IfcImpactProtectionDeviceTypeEnum.CRASHCUSHION + + +dampingsystem = IfcImpactProtectionDeviceTypeEnum.DAMPINGSYSTEM + + +fender = IfcImpactProtectionDeviceTypeEnum.FENDER + + +userdefined = IfcImpactProtectionDeviceTypeEnum.USERDEFINED + + +notdefined = IfcImpactProtectionDeviceTypeEnum.NOTDEFINED + + +IfcInterceptorTypeEnum = enum_namespace() + + +cyclonic = IfcInterceptorTypeEnum.CYCLONIC + + +grease = IfcInterceptorTypeEnum.GREASE + + +oil = IfcInterceptorTypeEnum.OIL + + +petrol = IfcInterceptorTypeEnum.PETROL + + +userdefined = IfcInterceptorTypeEnum.USERDEFINED + + +notdefined = IfcInterceptorTypeEnum.NOTDEFINED + + +IfcInternalOrExternalEnum = enum_namespace() + + +external = IfcInternalOrExternalEnum.EXTERNAL + + +external_earth = IfcInternalOrExternalEnum.EXTERNAL_EARTH + + +external_fire = IfcInternalOrExternalEnum.EXTERNAL_FIRE + + +external_water = IfcInternalOrExternalEnum.EXTERNAL_WATER + + +internal = IfcInternalOrExternalEnum.INTERNAL + + +notdefined = IfcInternalOrExternalEnum.NOTDEFINED + + +IfcInventoryTypeEnum = enum_namespace() + + +assetinventory = IfcInventoryTypeEnum.ASSETINVENTORY + + +furnitureinventory = IfcInventoryTypeEnum.FURNITUREINVENTORY + + +spaceinventory = IfcInventoryTypeEnum.SPACEINVENTORY + + +userdefined = IfcInventoryTypeEnum.USERDEFINED + + +notdefined = IfcInventoryTypeEnum.NOTDEFINED + + +IfcJunctionBoxTypeEnum = enum_namespace() + + +data = IfcJunctionBoxTypeEnum.DATA + + +power = IfcJunctionBoxTypeEnum.POWER + + +userdefined = IfcJunctionBoxTypeEnum.USERDEFINED + + +notdefined = IfcJunctionBoxTypeEnum.NOTDEFINED + + +IfcKerbTypeEnum = enum_namespace() + + +userdefined = IfcKerbTypeEnum.USERDEFINED + + +notdefined = IfcKerbTypeEnum.NOTDEFINED + + +IfcKnotType = enum_namespace() + + +piecewise_bezier_knots = IfcKnotType.PIECEWISE_BEZIER_KNOTS + + +quasi_uniform_knots = IfcKnotType.QUASI_UNIFORM_KNOTS + + +uniform_knots = IfcKnotType.UNIFORM_KNOTS + + +unspecified = IfcKnotType.UNSPECIFIED + + +IfcLaborResourceTypeEnum = enum_namespace() + + +administration = IfcLaborResourceTypeEnum.ADMINISTRATION + + +carpentry = IfcLaborResourceTypeEnum.CARPENTRY + + +cleaning = IfcLaborResourceTypeEnum.CLEANING + + +concrete = IfcLaborResourceTypeEnum.CONCRETE + + +drywall = IfcLaborResourceTypeEnum.DRYWALL + + +electric = IfcLaborResourceTypeEnum.ELECTRIC + + +finishing = IfcLaborResourceTypeEnum.FINISHING + + +flooring = IfcLaborResourceTypeEnum.FLOORING + + +general = IfcLaborResourceTypeEnum.GENERAL + + +hvac = IfcLaborResourceTypeEnum.HVAC + + +landscaping = IfcLaborResourceTypeEnum.LANDSCAPING + + +masonry = IfcLaborResourceTypeEnum.MASONRY + + +painting = IfcLaborResourceTypeEnum.PAINTING + + +paving = IfcLaborResourceTypeEnum.PAVING + + +plumbing = IfcLaborResourceTypeEnum.PLUMBING + + +roofing = IfcLaborResourceTypeEnum.ROOFING + + +sitegrading = IfcLaborResourceTypeEnum.SITEGRADING + + +steelwork = IfcLaborResourceTypeEnum.STEELWORK + + +surveying = IfcLaborResourceTypeEnum.SURVEYING + + +userdefined = IfcLaborResourceTypeEnum.USERDEFINED + + +notdefined = IfcLaborResourceTypeEnum.NOTDEFINED + + +IfcLampTypeEnum = enum_namespace() + + +compactfluorescent = IfcLampTypeEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLampTypeEnum.FLUORESCENT + + +halogen = IfcLampTypeEnum.HALOGEN + + +highpressuremercury = IfcLampTypeEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLampTypeEnum.HIGHPRESSURESODIUM + + +led = IfcLampTypeEnum.LED + + +metalhalide = IfcLampTypeEnum.METALHALIDE + + +oled = IfcLampTypeEnum.OLED + + +tungstenfilament = IfcLampTypeEnum.TUNGSTENFILAMENT + + +userdefined = IfcLampTypeEnum.USERDEFINED + + +notdefined = IfcLampTypeEnum.NOTDEFINED + + +IfcLayerSetDirectionEnum = enum_namespace() + + +axis1 = IfcLayerSetDirectionEnum.AXIS1 + + +axis2 = IfcLayerSetDirectionEnum.AXIS2 + + +axis3 = IfcLayerSetDirectionEnum.AXIS3 + + +IfcLightDistributionCurveEnum = enum_namespace() + + +type_a = IfcLightDistributionCurveEnum.TYPE_A + + +type_b = IfcLightDistributionCurveEnum.TYPE_B + + +type_c = IfcLightDistributionCurveEnum.TYPE_C + + +notdefined = IfcLightDistributionCurveEnum.NOTDEFINED + + +IfcLightEmissionSourceEnum = enum_namespace() + + +compactfluorescent = IfcLightEmissionSourceEnum.COMPACTFLUORESCENT + + +fluorescent = IfcLightEmissionSourceEnum.FLUORESCENT + + +highpressuremercury = IfcLightEmissionSourceEnum.HIGHPRESSUREMERCURY + + +highpressuresodium = IfcLightEmissionSourceEnum.HIGHPRESSURESODIUM + + +lightemittingdiode = IfcLightEmissionSourceEnum.LIGHTEMITTINGDIODE + + +lowpressuresodium = IfcLightEmissionSourceEnum.LOWPRESSURESODIUM + + +lowvoltagehalogen = IfcLightEmissionSourceEnum.LOWVOLTAGEHALOGEN + + +mainvoltagehalogen = IfcLightEmissionSourceEnum.MAINVOLTAGEHALOGEN + + +metalhalide = IfcLightEmissionSourceEnum.METALHALIDE + + +tungstenfilament = IfcLightEmissionSourceEnum.TUNGSTENFILAMENT + + +notdefined = IfcLightEmissionSourceEnum.NOTDEFINED + + +IfcLightFixtureTypeEnum = enum_namespace() + + +directionsource = IfcLightFixtureTypeEnum.DIRECTIONSOURCE + + +pointsource = IfcLightFixtureTypeEnum.POINTSOURCE + + +securitylighting = IfcLightFixtureTypeEnum.SECURITYLIGHTING + + +userdefined = IfcLightFixtureTypeEnum.USERDEFINED + + +notdefined = IfcLightFixtureTypeEnum.NOTDEFINED + + +IfcLiquidTerminalTypeEnum = enum_namespace() + + +hosereel = IfcLiquidTerminalTypeEnum.HOSEREEL + + +loadingarm = IfcLiquidTerminalTypeEnum.LOADINGARM + + +userdefined = IfcLiquidTerminalTypeEnum.USERDEFINED + + +notdefined = IfcLiquidTerminalTypeEnum.NOTDEFINED + + +IfcLoadGroupTypeEnum = enum_namespace() + + +load_case = IfcLoadGroupTypeEnum.LOAD_CASE + + +load_combination = IfcLoadGroupTypeEnum.LOAD_COMBINATION + + +load_group = IfcLoadGroupTypeEnum.LOAD_GROUP + + +userdefined = IfcLoadGroupTypeEnum.USERDEFINED + + +notdefined = IfcLoadGroupTypeEnum.NOTDEFINED + + +IfcLogicalOperatorEnum = enum_namespace() + + +logicaland = IfcLogicalOperatorEnum.LOGICALAND + + +logicalnotand = IfcLogicalOperatorEnum.LOGICALNOTAND + + +logicalnotor = IfcLogicalOperatorEnum.LOGICALNOTOR + + +logicalor = IfcLogicalOperatorEnum.LOGICALOR + + +logicalxor = IfcLogicalOperatorEnum.LOGICALXOR + + +IfcMarineFacilityTypeEnum = enum_namespace() + + +barrierbeach = IfcMarineFacilityTypeEnum.BARRIERBEACH + + +breakwater = IfcMarineFacilityTypeEnum.BREAKWATER + + +canal = IfcMarineFacilityTypeEnum.CANAL + + +drydock = IfcMarineFacilityTypeEnum.DRYDOCK + + +floatingdock = IfcMarineFacilityTypeEnum.FLOATINGDOCK + + +hydrolift = IfcMarineFacilityTypeEnum.HYDROLIFT + + +jetty = IfcMarineFacilityTypeEnum.JETTY + + +launchrecovery = IfcMarineFacilityTypeEnum.LAUNCHRECOVERY + + +marinedefence = IfcMarineFacilityTypeEnum.MARINEDEFENCE + + +navigationalchannel = IfcMarineFacilityTypeEnum.NAVIGATIONALCHANNEL + + +port = IfcMarineFacilityTypeEnum.PORT + + +quay = IfcMarineFacilityTypeEnum.QUAY + + +revetment = IfcMarineFacilityTypeEnum.REVETMENT + + +shiplift = IfcMarineFacilityTypeEnum.SHIPLIFT + + +shiplock = IfcMarineFacilityTypeEnum.SHIPLOCK + + +shipyard = IfcMarineFacilityTypeEnum.SHIPYARD + + +slipway = IfcMarineFacilityTypeEnum.SLIPWAY + + +waterway = IfcMarineFacilityTypeEnum.WATERWAY + + +waterwayshiplift = IfcMarineFacilityTypeEnum.WATERWAYSHIPLIFT + + +userdefined = IfcMarineFacilityTypeEnum.USERDEFINED + + +notdefined = IfcMarineFacilityTypeEnum.NOTDEFINED + + +IfcMarinePartTypeEnum = enum_namespace() + + +abovewaterline = IfcMarinePartTypeEnum.ABOVEWATERLINE + + +anchorage = IfcMarinePartTypeEnum.ANCHORAGE + + +approachchannel = IfcMarinePartTypeEnum.APPROACHCHANNEL + + +belowwaterline = IfcMarinePartTypeEnum.BELOWWATERLINE + + +berthingstructure = IfcMarinePartTypeEnum.BERTHINGSTRUCTURE + + +chamber = IfcMarinePartTypeEnum.CHAMBER + + +cill_level = IfcMarinePartTypeEnum.CILL_LEVEL + + +copelevel = IfcMarinePartTypeEnum.COPELEVEL + + +core = IfcMarinePartTypeEnum.CORE + + +crest = IfcMarinePartTypeEnum.CREST + + +gatehead = IfcMarinePartTypeEnum.GATEHEAD + + +gudingstructure = IfcMarinePartTypeEnum.GUDINGSTRUCTURE + + +highwaterline = IfcMarinePartTypeEnum.HIGHWATERLINE + + +landfield = IfcMarinePartTypeEnum.LANDFIELD + + +leewardside = IfcMarinePartTypeEnum.LEEWARDSIDE + + +lowwaterline = IfcMarinePartTypeEnum.LOWWATERLINE + + +manufacturing = IfcMarinePartTypeEnum.MANUFACTURING + + +navigationalarea = IfcMarinePartTypeEnum.NAVIGATIONALAREA + + +protection = IfcMarinePartTypeEnum.PROTECTION + + +shiptransfer = IfcMarinePartTypeEnum.SHIPTRANSFER + + +storagearea = IfcMarinePartTypeEnum.STORAGEAREA + + +vehicleservicing = IfcMarinePartTypeEnum.VEHICLESERVICING + + +waterfield = IfcMarinePartTypeEnum.WATERFIELD + + +weatherside = IfcMarinePartTypeEnum.WEATHERSIDE + + +userdefined = IfcMarinePartTypeEnum.USERDEFINED + + +notdefined = IfcMarinePartTypeEnum.NOTDEFINED + + +IfcMechanicalFastenerTypeEnum = enum_namespace() + + +anchorbolt = IfcMechanicalFastenerTypeEnum.ANCHORBOLT + + +bolt = IfcMechanicalFastenerTypeEnum.BOLT + + +chain = IfcMechanicalFastenerTypeEnum.CHAIN + + +coupler = IfcMechanicalFastenerTypeEnum.COUPLER + + +dowel = IfcMechanicalFastenerTypeEnum.DOWEL + + +nail = IfcMechanicalFastenerTypeEnum.NAIL + + +nailplate = IfcMechanicalFastenerTypeEnum.NAILPLATE + + +railfastening = IfcMechanicalFastenerTypeEnum.RAILFASTENING + + +railjoint = IfcMechanicalFastenerTypeEnum.RAILJOINT + + +rivet = IfcMechanicalFastenerTypeEnum.RIVET + + +rope = IfcMechanicalFastenerTypeEnum.ROPE + + +screw = IfcMechanicalFastenerTypeEnum.SCREW + + +shearconnector = IfcMechanicalFastenerTypeEnum.SHEARCONNECTOR + + +staple = IfcMechanicalFastenerTypeEnum.STAPLE + + +studshearconnector = IfcMechanicalFastenerTypeEnum.STUDSHEARCONNECTOR + + +userdefined = IfcMechanicalFastenerTypeEnum.USERDEFINED + + +notdefined = IfcMechanicalFastenerTypeEnum.NOTDEFINED + + +IfcMedicalDeviceTypeEnum = enum_namespace() + + +airstation = IfcMedicalDeviceTypeEnum.AIRSTATION + + +feedairunit = IfcMedicalDeviceTypeEnum.FEEDAIRUNIT + + +oxygengenerator = IfcMedicalDeviceTypeEnum.OXYGENGENERATOR + + +oxygenplant = IfcMedicalDeviceTypeEnum.OXYGENPLANT + + +vacuumstation = IfcMedicalDeviceTypeEnum.VACUUMSTATION + + +userdefined = IfcMedicalDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMedicalDeviceTypeEnum.NOTDEFINED + + +IfcMemberTypeEnum = enum_namespace() + + +arch_segment = IfcMemberTypeEnum.ARCH_SEGMENT + + +brace = IfcMemberTypeEnum.BRACE + + +chord = IfcMemberTypeEnum.CHORD + + +collar = IfcMemberTypeEnum.COLLAR + + +member = IfcMemberTypeEnum.MEMBER + + +mullion = IfcMemberTypeEnum.MULLION + + +plate = IfcMemberTypeEnum.PLATE + + +post = IfcMemberTypeEnum.POST + + +purlin = IfcMemberTypeEnum.PURLIN + + +rafter = IfcMemberTypeEnum.RAFTER + + +stay_cable = IfcMemberTypeEnum.STAY_CABLE + + +stiffening_rib = IfcMemberTypeEnum.STIFFENING_RIB + + +stringer = IfcMemberTypeEnum.STRINGER + + +structuralcable = IfcMemberTypeEnum.STRUCTURALCABLE + + +strut = IfcMemberTypeEnum.STRUT + + +stud = IfcMemberTypeEnum.STUD + + +suspender = IfcMemberTypeEnum.SUSPENDER + + +suspension_cable = IfcMemberTypeEnum.SUSPENSION_CABLE + + +tiebar = IfcMemberTypeEnum.TIEBAR + + +userdefined = IfcMemberTypeEnum.USERDEFINED + + +notdefined = IfcMemberTypeEnum.NOTDEFINED + + +IfcMobileTelecommunicationsApplianceTypeEnum = enum_namespace() + + +accesspoint = IfcMobileTelecommunicationsApplianceTypeEnum.ACCESSPOINT + + +basebandunit = IfcMobileTelecommunicationsApplianceTypeEnum.BASEBANDUNIT + + +basetransceiverstation = IfcMobileTelecommunicationsApplianceTypeEnum.BASETRANSCEIVERSTATION + + +e_utran_node_b = IfcMobileTelecommunicationsApplianceTypeEnum.E_UTRAN_NODE_B + + +gateway_gprs_support_node = IfcMobileTelecommunicationsApplianceTypeEnum.GATEWAY_GPRS_SUPPORT_NODE + + +masterunit = IfcMobileTelecommunicationsApplianceTypeEnum.MASTERUNIT + + +mobileswitchingcenter = IfcMobileTelecommunicationsApplianceTypeEnum.MOBILESWITCHINGCENTER + + +mscserver = IfcMobileTelecommunicationsApplianceTypeEnum.MSCSERVER + + +packetcontrolunit = IfcMobileTelecommunicationsApplianceTypeEnum.PACKETCONTROLUNIT + + +remoteradiounit = IfcMobileTelecommunicationsApplianceTypeEnum.REMOTERADIOUNIT + + +remoteunit = IfcMobileTelecommunicationsApplianceTypeEnum.REMOTEUNIT + + +service_gprs_support_node = IfcMobileTelecommunicationsApplianceTypeEnum.SERVICE_GPRS_SUPPORT_NODE + + +subscriberserver = IfcMobileTelecommunicationsApplianceTypeEnum.SUBSCRIBERSERVER + + +userdefined = IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED + + +notdefined = IfcMobileTelecommunicationsApplianceTypeEnum.NOTDEFINED + + +IfcMooringDeviceTypeEnum = enum_namespace() + + +bollard = IfcMooringDeviceTypeEnum.BOLLARD + + +linetensioner = IfcMooringDeviceTypeEnum.LINETENSIONER + + +magneticdevice = IfcMooringDeviceTypeEnum.MAGNETICDEVICE + + +mooringhooks = IfcMooringDeviceTypeEnum.MOORINGHOOKS + + +vacuumdevice = IfcMooringDeviceTypeEnum.VACUUMDEVICE + + +userdefined = IfcMooringDeviceTypeEnum.USERDEFINED + + +notdefined = IfcMooringDeviceTypeEnum.NOTDEFINED + + +IfcMotorConnectionTypeEnum = enum_namespace() + + +beltdrive = IfcMotorConnectionTypeEnum.BELTDRIVE + + +coupling = IfcMotorConnectionTypeEnum.COUPLING + + +directdrive = IfcMotorConnectionTypeEnum.DIRECTDRIVE + + +userdefined = IfcMotorConnectionTypeEnum.USERDEFINED + + +notdefined = IfcMotorConnectionTypeEnum.NOTDEFINED + + +IfcNavigationElementTypeEnum = enum_namespace() + + +beacon = IfcNavigationElementTypeEnum.BEACON + + +buoy = IfcNavigationElementTypeEnum.BUOY + + +userdefined = IfcNavigationElementTypeEnum.USERDEFINED + + +notdefined = IfcNavigationElementTypeEnum.NOTDEFINED + + +IfcObjectiveEnum = enum_namespace() + + +codecompliance = IfcObjectiveEnum.CODECOMPLIANCE + + +codewaiver = IfcObjectiveEnum.CODEWAIVER + + +designintent = IfcObjectiveEnum.DESIGNINTENT + + +external = IfcObjectiveEnum.EXTERNAL + + +healthandsafety = IfcObjectiveEnum.HEALTHANDSAFETY + + +mergeconflict = IfcObjectiveEnum.MERGECONFLICT + + +modelview = IfcObjectiveEnum.MODELVIEW + + +parameter = IfcObjectiveEnum.PARAMETER + + +requirement = IfcObjectiveEnum.REQUIREMENT + + +specification = IfcObjectiveEnum.SPECIFICATION + + +triggercondition = IfcObjectiveEnum.TRIGGERCONDITION + + +userdefined = IfcObjectiveEnum.USERDEFINED + + +notdefined = IfcObjectiveEnum.NOTDEFINED + + +IfcOccupantTypeEnum = enum_namespace() + + +assignee = IfcOccupantTypeEnum.ASSIGNEE + + +assignor = IfcOccupantTypeEnum.ASSIGNOR + + +lessee = IfcOccupantTypeEnum.LESSEE + + +lessor = IfcOccupantTypeEnum.LESSOR + + +lettingagent = IfcOccupantTypeEnum.LETTINGAGENT + + +owner = IfcOccupantTypeEnum.OWNER + + +tenant = IfcOccupantTypeEnum.TENANT + + +userdefined = IfcOccupantTypeEnum.USERDEFINED + + +notdefined = IfcOccupantTypeEnum.NOTDEFINED + + +IfcOpeningElementTypeEnum = enum_namespace() + + +opening = IfcOpeningElementTypeEnum.OPENING + + +recess = IfcOpeningElementTypeEnum.RECESS + + +userdefined = IfcOpeningElementTypeEnum.USERDEFINED + + +notdefined = IfcOpeningElementTypeEnum.NOTDEFINED + + +IfcOutletTypeEnum = enum_namespace() + + +audiovisualoutlet = IfcOutletTypeEnum.AUDIOVISUALOUTLET + + +communicationsoutlet = IfcOutletTypeEnum.COMMUNICATIONSOUTLET + + +dataoutlet = IfcOutletTypeEnum.DATAOUTLET + + +poweroutlet = IfcOutletTypeEnum.POWEROUTLET + + +telephoneoutlet = IfcOutletTypeEnum.TELEPHONEOUTLET + + +userdefined = IfcOutletTypeEnum.USERDEFINED + + +notdefined = IfcOutletTypeEnum.NOTDEFINED + + +IfcPavementTypeEnum = enum_namespace() + + +flexible = IfcPavementTypeEnum.FLEXIBLE + + +rigid = IfcPavementTypeEnum.RIGID + + +userdefined = IfcPavementTypeEnum.USERDEFINED + + +notdefined = IfcPavementTypeEnum.NOTDEFINED + + +IfcPerformanceHistoryTypeEnum = enum_namespace() + + +userdefined = IfcPerformanceHistoryTypeEnum.USERDEFINED + + +notdefined = IfcPerformanceHistoryTypeEnum.NOTDEFINED + + +IfcPermeableCoveringOperationEnum = enum_namespace() + + +grill = IfcPermeableCoveringOperationEnum.GRILL + + +louver = IfcPermeableCoveringOperationEnum.LOUVER + + +screen = IfcPermeableCoveringOperationEnum.SCREEN + + +userdefined = IfcPermeableCoveringOperationEnum.USERDEFINED + + +notdefined = IfcPermeableCoveringOperationEnum.NOTDEFINED + + +IfcPermitTypeEnum = enum_namespace() + + +access = IfcPermitTypeEnum.ACCESS + + +building = IfcPermitTypeEnum.BUILDING + + +work = IfcPermitTypeEnum.WORK + + +userdefined = IfcPermitTypeEnum.USERDEFINED + + +notdefined = IfcPermitTypeEnum.NOTDEFINED + + +IfcPhysicalOrVirtualEnum = enum_namespace() + + +physical = IfcPhysicalOrVirtualEnum.PHYSICAL + + +virtual = IfcPhysicalOrVirtualEnum.VIRTUAL + + +notdefined = IfcPhysicalOrVirtualEnum.NOTDEFINED + + +IfcPileConstructionEnum = enum_namespace() + + +cast_in_place = IfcPileConstructionEnum.CAST_IN_PLACE + + +composite = IfcPileConstructionEnum.COMPOSITE + + +precast_concrete = IfcPileConstructionEnum.PRECAST_CONCRETE + + +prefab_steel = IfcPileConstructionEnum.PREFAB_STEEL + + +userdefined = IfcPileConstructionEnum.USERDEFINED + + +notdefined = IfcPileConstructionEnum.NOTDEFINED + + +IfcPileTypeEnum = enum_namespace() + + +bored = IfcPileTypeEnum.BORED + + +cohesion = IfcPileTypeEnum.COHESION + + +driven = IfcPileTypeEnum.DRIVEN + + +friction = IfcPileTypeEnum.FRICTION + + +jetgrouting = IfcPileTypeEnum.JETGROUTING + + +support = IfcPileTypeEnum.SUPPORT + + +userdefined = IfcPileTypeEnum.USERDEFINED + + +notdefined = IfcPileTypeEnum.NOTDEFINED + + +IfcPipeFittingTypeEnum = enum_namespace() + + +bend = IfcPipeFittingTypeEnum.BEND + + +connector = IfcPipeFittingTypeEnum.CONNECTOR + + +entry = IfcPipeFittingTypeEnum.ENTRY + + +exit = IfcPipeFittingTypeEnum.EXIT + + +junction = IfcPipeFittingTypeEnum.JUNCTION + + +obstruction = IfcPipeFittingTypeEnum.OBSTRUCTION + + +transition = IfcPipeFittingTypeEnum.TRANSITION + + +userdefined = IfcPipeFittingTypeEnum.USERDEFINED + + +notdefined = IfcPipeFittingTypeEnum.NOTDEFINED + + +IfcPipeSegmentTypeEnum = enum_namespace() + + +culvert = IfcPipeSegmentTypeEnum.CULVERT + + +flexiblesegment = IfcPipeSegmentTypeEnum.FLEXIBLESEGMENT + + +gutter = IfcPipeSegmentTypeEnum.GUTTER + + +rigidsegment = IfcPipeSegmentTypeEnum.RIGIDSEGMENT + + +spool = IfcPipeSegmentTypeEnum.SPOOL + + +userdefined = IfcPipeSegmentTypeEnum.USERDEFINED + + +notdefined = IfcPipeSegmentTypeEnum.NOTDEFINED + + +IfcPlateTypeEnum = enum_namespace() + + +base_plate = IfcPlateTypeEnum.BASE_PLATE + + +cover_plate = IfcPlateTypeEnum.COVER_PLATE + + +curtain_panel = IfcPlateTypeEnum.CURTAIN_PANEL + + +flange_plate = IfcPlateTypeEnum.FLANGE_PLATE + + +gusset_plate = IfcPlateTypeEnum.GUSSET_PLATE + + +sheet = IfcPlateTypeEnum.SHEET + + +splice_plate = IfcPlateTypeEnum.SPLICE_PLATE + + +stiffener_plate = IfcPlateTypeEnum.STIFFENER_PLATE + + +web_plate = IfcPlateTypeEnum.WEB_PLATE + + +userdefined = IfcPlateTypeEnum.USERDEFINED + + +notdefined = IfcPlateTypeEnum.NOTDEFINED + + +IfcPreferredSurfaceCurveRepresentation = enum_namespace() + + +curve3d = IfcPreferredSurfaceCurveRepresentation.CURVE3D + + +pcurve_s1 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S1 + + +pcurve_s2 = IfcPreferredSurfaceCurveRepresentation.PCURVE_S2 + + +IfcProcedureTypeEnum = enum_namespace() + + +advice_caution = IfcProcedureTypeEnum.ADVICE_CAUTION + + +advice_note = IfcProcedureTypeEnum.ADVICE_NOTE + + +advice_warning = IfcProcedureTypeEnum.ADVICE_WARNING + + +calibration = IfcProcedureTypeEnum.CALIBRATION + + +diagnostic = IfcProcedureTypeEnum.DIAGNOSTIC + + +shutdown = IfcProcedureTypeEnum.SHUTDOWN + + +startup = IfcProcedureTypeEnum.STARTUP + + +userdefined = IfcProcedureTypeEnum.USERDEFINED + + +notdefined = IfcProcedureTypeEnum.NOTDEFINED + + +IfcProfileTypeEnum = enum_namespace() + + +area = IfcProfileTypeEnum.AREA + + +curve = IfcProfileTypeEnum.CURVE + + +IfcProjectOrderTypeEnum = enum_namespace() + + +changeorder = IfcProjectOrderTypeEnum.CHANGEORDER + + +maintenanceworkorder = IfcProjectOrderTypeEnum.MAINTENANCEWORKORDER + + +moveorder = IfcProjectOrderTypeEnum.MOVEORDER + + +purchaseorder = IfcProjectOrderTypeEnum.PURCHASEORDER + + +workorder = IfcProjectOrderTypeEnum.WORKORDER + + +userdefined = IfcProjectOrderTypeEnum.USERDEFINED + + +notdefined = IfcProjectOrderTypeEnum.NOTDEFINED + + +IfcProjectedOrTrueLengthEnum = enum_namespace() + + +projected_length = IfcProjectedOrTrueLengthEnum.PROJECTED_LENGTH + + +true_length = IfcProjectedOrTrueLengthEnum.TRUE_LENGTH + + +IfcProjectionElementTypeEnum = enum_namespace() + + +blister = IfcProjectionElementTypeEnum.BLISTER + + +deviator = IfcProjectionElementTypeEnum.DEVIATOR + + +userdefined = IfcProjectionElementTypeEnum.USERDEFINED + + +notdefined = IfcProjectionElementTypeEnum.NOTDEFINED + + +IfcPropertySetTemplateTypeEnum = enum_namespace() + + +pset_materialdriven = IfcPropertySetTemplateTypeEnum.PSET_MATERIALDRIVEN + + +pset_occurrencedriven = IfcPropertySetTemplateTypeEnum.PSET_OCCURRENCEDRIVEN + + +pset_performancedriven = IfcPropertySetTemplateTypeEnum.PSET_PERFORMANCEDRIVEN + + +pset_profiledriven = IfcPropertySetTemplateTypeEnum.PSET_PROFILEDRIVEN + + +pset_typedrivenonly = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENONLY + + +pset_typedrivenoverride = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENOVERRIDE + + +qto_occurrencedriven = IfcPropertySetTemplateTypeEnum.QTO_OCCURRENCEDRIVEN + + +qto_typedrivenonly = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENONLY + + +qto_typedrivenoverride = IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENOVERRIDE + + +notdefined = IfcPropertySetTemplateTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTrippingUnitTypeEnum = enum_namespace() + + +electromagnetic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTROMAGNETIC + + +electronic = IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTRONIC + + +residualcurrent = IfcProtectiveDeviceTrippingUnitTypeEnum.RESIDUALCURRENT + + +thermal = IfcProtectiveDeviceTrippingUnitTypeEnum.THERMAL + + +userdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTrippingUnitTypeEnum.NOTDEFINED + + +IfcProtectiveDeviceTypeEnum = enum_namespace() + + +anti_arcing_device = IfcProtectiveDeviceTypeEnum.ANTI_ARCING_DEVICE + + +circuitbreaker = IfcProtectiveDeviceTypeEnum.CIRCUITBREAKER + + +earthingswitch = IfcProtectiveDeviceTypeEnum.EARTHINGSWITCH + + +earthleakagecircuitbreaker = IfcProtectiveDeviceTypeEnum.EARTHLEAKAGECIRCUITBREAKER + + +fusedisconnector = IfcProtectiveDeviceTypeEnum.FUSEDISCONNECTOR + + +residualcurrentcircuitbreaker = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTCIRCUITBREAKER + + +residualcurrentswitch = IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTSWITCH + + +sparkgap = IfcProtectiveDeviceTypeEnum.SPARKGAP + + +varistor = IfcProtectiveDeviceTypeEnum.VARISTOR + + +voltagelimiter = IfcProtectiveDeviceTypeEnum.VOLTAGELIMITER + + +userdefined = IfcProtectiveDeviceTypeEnum.USERDEFINED + + +notdefined = IfcProtectiveDeviceTypeEnum.NOTDEFINED + + +IfcPumpTypeEnum = enum_namespace() + + +circulator = IfcPumpTypeEnum.CIRCULATOR + + +endsuction = IfcPumpTypeEnum.ENDSUCTION + + +splitcase = IfcPumpTypeEnum.SPLITCASE + + +submersiblepump = IfcPumpTypeEnum.SUBMERSIBLEPUMP + + +sumppump = IfcPumpTypeEnum.SUMPPUMP + + +verticalinline = IfcPumpTypeEnum.VERTICALINLINE + + +verticalturbine = IfcPumpTypeEnum.VERTICALTURBINE + + +userdefined = IfcPumpTypeEnum.USERDEFINED + + +notdefined = IfcPumpTypeEnum.NOTDEFINED + + +IfcRailTypeEnum = enum_namespace() + + +blade = IfcRailTypeEnum.BLADE + + +checkrail = IfcRailTypeEnum.CHECKRAIL + + +guardrail = IfcRailTypeEnum.GUARDRAIL + + +rackrail = IfcRailTypeEnum.RACKRAIL + + +rail = IfcRailTypeEnum.RAIL + + +stockrail = IfcRailTypeEnum.STOCKRAIL + + +userdefined = IfcRailTypeEnum.USERDEFINED + + +notdefined = IfcRailTypeEnum.NOTDEFINED + + +IfcRailingTypeEnum = enum_namespace() + + +balustrade = IfcRailingTypeEnum.BALUSTRADE + + +fence = IfcRailingTypeEnum.FENCE + + +guardrail = IfcRailingTypeEnum.GUARDRAIL + + +handrail = IfcRailingTypeEnum.HANDRAIL + + +userdefined = IfcRailingTypeEnum.USERDEFINED + + +notdefined = IfcRailingTypeEnum.NOTDEFINED + + +IfcRailwayPartTypeEnum = enum_namespace() + + +dilatationsuperstructure = IfcRailwayPartTypeEnum.DILATATIONSUPERSTRUCTURE + + +linesidestructure = IfcRailwayPartTypeEnum.LINESIDESTRUCTURE + + +linesidestructurepart = IfcRailwayPartTypeEnum.LINESIDESTRUCTUREPART + + +plaintracksuperstructure = IfcRailwayPartTypeEnum.PLAINTRACKSUPERSTRUCTURE + + +superstructure = IfcRailwayPartTypeEnum.SUPERSTRUCTURE + + +trackstructure = IfcRailwayPartTypeEnum.TRACKSTRUCTURE + + +trackstructurepart = IfcRailwayPartTypeEnum.TRACKSTRUCTUREPART + + +turnoutsuperstructure = IfcRailwayPartTypeEnum.TURNOUTSUPERSTRUCTURE + + +userdefined = IfcRailwayPartTypeEnum.USERDEFINED + + +notdefined = IfcRailwayPartTypeEnum.NOTDEFINED + + +IfcRailwayTypeEnum = enum_namespace() + + +userdefined = IfcRailwayTypeEnum.USERDEFINED + + +notdefined = IfcRailwayTypeEnum.NOTDEFINED + + +IfcRampFlightTypeEnum = enum_namespace() + + +spiral = IfcRampFlightTypeEnum.SPIRAL + + +straight = IfcRampFlightTypeEnum.STRAIGHT + + +userdefined = IfcRampFlightTypeEnum.USERDEFINED + + +notdefined = IfcRampFlightTypeEnum.NOTDEFINED + + +IfcRampTypeEnum = enum_namespace() + + +half_turn_ramp = IfcRampTypeEnum.HALF_TURN_RAMP + + +quarter_turn_ramp = IfcRampTypeEnum.QUARTER_TURN_RAMP + + +spiral_ramp = IfcRampTypeEnum.SPIRAL_RAMP + + +straight_run_ramp = IfcRampTypeEnum.STRAIGHT_RUN_RAMP + + +two_quarter_turn_ramp = IfcRampTypeEnum.TWO_QUARTER_TURN_RAMP + + +two_straight_run_ramp = IfcRampTypeEnum.TWO_STRAIGHT_RUN_RAMP + + +userdefined = IfcRampTypeEnum.USERDEFINED + + +notdefined = IfcRampTypeEnum.NOTDEFINED + + +IfcRecurrenceTypeEnum = enum_namespace() + + +by_day_count = IfcRecurrenceTypeEnum.BY_DAY_COUNT + + +by_weekday_count = IfcRecurrenceTypeEnum.BY_WEEKDAY_COUNT + + +daily = IfcRecurrenceTypeEnum.DAILY + + +monthly_by_day_of_month = IfcRecurrenceTypeEnum.MONTHLY_BY_DAY_OF_MONTH + + +monthly_by_position = IfcRecurrenceTypeEnum.MONTHLY_BY_POSITION + + +weekly = IfcRecurrenceTypeEnum.WEEKLY + + +yearly_by_day_of_month = IfcRecurrenceTypeEnum.YEARLY_BY_DAY_OF_MONTH + + +yearly_by_position = IfcRecurrenceTypeEnum.YEARLY_BY_POSITION + + +IfcReferentTypeEnum = enum_namespace() + + +boundary = IfcReferentTypeEnum.BOUNDARY + + +intersection = IfcReferentTypeEnum.INTERSECTION + + +kilopoint = IfcReferentTypeEnum.KILOPOINT + + +landmark = IfcReferentTypeEnum.LANDMARK + + +milepoint = IfcReferentTypeEnum.MILEPOINT + + +position = IfcReferentTypeEnum.POSITION + + +referencemarker = IfcReferentTypeEnum.REFERENCEMARKER + + +station = IfcReferentTypeEnum.STATION + + +userdefined = IfcReferentTypeEnum.USERDEFINED + + +notdefined = IfcReferentTypeEnum.NOTDEFINED + + +IfcReflectanceMethodEnum = enum_namespace() + + +blinn = IfcReflectanceMethodEnum.BLINN + + +flat = IfcReflectanceMethodEnum.FLAT + + +glass = IfcReflectanceMethodEnum.GLASS + + +matt = IfcReflectanceMethodEnum.MATT + + +metal = IfcReflectanceMethodEnum.METAL + + +mirror = IfcReflectanceMethodEnum.MIRROR + + +phong = IfcReflectanceMethodEnum.PHONG + + +physical = IfcReflectanceMethodEnum.PHYSICAL + + +plastic = IfcReflectanceMethodEnum.PLASTIC + + +strauss = IfcReflectanceMethodEnum.STRAUSS + + +notdefined = IfcReflectanceMethodEnum.NOTDEFINED + + +IfcReinforcedSoilTypeEnum = enum_namespace() + + +dynamicallycompacted = IfcReinforcedSoilTypeEnum.DYNAMICALLYCOMPACTED + + +grouted = IfcReinforcedSoilTypeEnum.GROUTED + + +replaced = IfcReinforcedSoilTypeEnum.REPLACED + + +rollercompacted = IfcReinforcedSoilTypeEnum.ROLLERCOMPACTED + + +surchargepreloaded = IfcReinforcedSoilTypeEnum.SURCHARGEPRELOADED + + +verticallydrained = IfcReinforcedSoilTypeEnum.VERTICALLYDRAINED + + +userdefined = IfcReinforcedSoilTypeEnum.USERDEFINED + + +notdefined = IfcReinforcedSoilTypeEnum.NOTDEFINED + + +IfcReinforcingBarRoleEnum = enum_namespace() + + +anchoring = IfcReinforcingBarRoleEnum.ANCHORING + + +edge = IfcReinforcingBarRoleEnum.EDGE + + +ligature = IfcReinforcingBarRoleEnum.LIGATURE + + +main = IfcReinforcingBarRoleEnum.MAIN + + +punching = IfcReinforcingBarRoleEnum.PUNCHING + + +ring = IfcReinforcingBarRoleEnum.RING + + +shear = IfcReinforcingBarRoleEnum.SHEAR + + +stud = IfcReinforcingBarRoleEnum.STUD + + +userdefined = IfcReinforcingBarRoleEnum.USERDEFINED + + +notdefined = IfcReinforcingBarRoleEnum.NOTDEFINED + + +IfcReinforcingBarSurfaceEnum = enum_namespace() + + +plain = IfcReinforcingBarSurfaceEnum.PLAIN + + +textured = IfcReinforcingBarSurfaceEnum.TEXTURED + + +IfcReinforcingBarTypeEnum = enum_namespace() + + +anchoring = IfcReinforcingBarTypeEnum.ANCHORING + + +edge = IfcReinforcingBarTypeEnum.EDGE + + +ligature = IfcReinforcingBarTypeEnum.LIGATURE + + +main = IfcReinforcingBarTypeEnum.MAIN + + +punching = IfcReinforcingBarTypeEnum.PUNCHING + + +ring = IfcReinforcingBarTypeEnum.RING + + +shear = IfcReinforcingBarTypeEnum.SHEAR + + +spacebar = IfcReinforcingBarTypeEnum.SPACEBAR + + +stud = IfcReinforcingBarTypeEnum.STUD + + +userdefined = IfcReinforcingBarTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingBarTypeEnum.NOTDEFINED + + +IfcReinforcingMeshTypeEnum = enum_namespace() + + +userdefined = IfcReinforcingMeshTypeEnum.USERDEFINED + + +notdefined = IfcReinforcingMeshTypeEnum.NOTDEFINED + + +IfcRoadPartTypeEnum = enum_namespace() + + +bicyclecrossing = IfcRoadPartTypeEnum.BICYCLECROSSING + + +bus_stop = IfcRoadPartTypeEnum.BUS_STOP + + +carriageway = IfcRoadPartTypeEnum.CARRIAGEWAY + + +centralisland = IfcRoadPartTypeEnum.CENTRALISLAND + + +centralreserve = IfcRoadPartTypeEnum.CENTRALRESERVE + + +hardshoulder = IfcRoadPartTypeEnum.HARDSHOULDER + + +intersection = IfcRoadPartTypeEnum.INTERSECTION + + +layby = IfcRoadPartTypeEnum.LAYBY + + +parkingbay = IfcRoadPartTypeEnum.PARKINGBAY + + +passingbay = IfcRoadPartTypeEnum.PASSINGBAY + + +pedestrian_crossing = IfcRoadPartTypeEnum.PEDESTRIAN_CROSSING + + +railwaycrossing = IfcRoadPartTypeEnum.RAILWAYCROSSING + + +refugeisland = IfcRoadPartTypeEnum.REFUGEISLAND + + +roadsegment = IfcRoadPartTypeEnum.ROADSEGMENT + + +roadside = IfcRoadPartTypeEnum.ROADSIDE + + +roadsidepart = IfcRoadPartTypeEnum.ROADSIDEPART + + +roadwayplateau = IfcRoadPartTypeEnum.ROADWAYPLATEAU + + +roundabout = IfcRoadPartTypeEnum.ROUNDABOUT + + +shoulder = IfcRoadPartTypeEnum.SHOULDER + + +sidewalk = IfcRoadPartTypeEnum.SIDEWALK + + +softshoulder = IfcRoadPartTypeEnum.SOFTSHOULDER + + +tollplaza = IfcRoadPartTypeEnum.TOLLPLAZA + + +trafficisland = IfcRoadPartTypeEnum.TRAFFICISLAND + + +trafficlane = IfcRoadPartTypeEnum.TRAFFICLANE + + +userdefined = IfcRoadPartTypeEnum.USERDEFINED + + +notdefined = IfcRoadPartTypeEnum.NOTDEFINED + + +IfcRoadTypeEnum = enum_namespace() + + +userdefined = IfcRoadTypeEnum.USERDEFINED + + +notdefined = IfcRoadTypeEnum.NOTDEFINED + + +IfcRoleEnum = enum_namespace() + + +architect = IfcRoleEnum.ARCHITECT + + +buildingoperator = IfcRoleEnum.BUILDINGOPERATOR + + +buildingowner = IfcRoleEnum.BUILDINGOWNER + + +civilengineer = IfcRoleEnum.CIVILENGINEER + + +client = IfcRoleEnum.CLIENT + + +commissioningengineer = IfcRoleEnum.COMMISSIONINGENGINEER + + +constructionmanager = IfcRoleEnum.CONSTRUCTIONMANAGER + + +consultant = IfcRoleEnum.CONSULTANT + + +contractor = IfcRoleEnum.CONTRACTOR + + +costengineer = IfcRoleEnum.COSTENGINEER + + +electricalengineer = IfcRoleEnum.ELECTRICALENGINEER + + +engineer = IfcRoleEnum.ENGINEER + + +facilitiesmanager = IfcRoleEnum.FACILITIESMANAGER + + +fieldconstructionmanager = IfcRoleEnum.FIELDCONSTRUCTIONMANAGER + + +manufacturer = IfcRoleEnum.MANUFACTURER + + +mechanicalengineer = IfcRoleEnum.MECHANICALENGINEER + + +owner = IfcRoleEnum.OWNER + + +projectmanager = IfcRoleEnum.PROJECTMANAGER + + +reseller = IfcRoleEnum.RESELLER + + +structuralengineer = IfcRoleEnum.STRUCTURALENGINEER + + +subcontractor = IfcRoleEnum.SUBCONTRACTOR + + +supplier = IfcRoleEnum.SUPPLIER + + +userdefined = IfcRoleEnum.USERDEFINED + + +IfcRoofTypeEnum = enum_namespace() + + +barrel_roof = IfcRoofTypeEnum.BARREL_ROOF + + +butterfly_roof = IfcRoofTypeEnum.BUTTERFLY_ROOF + + +dome_roof = IfcRoofTypeEnum.DOME_ROOF + + +flat_roof = IfcRoofTypeEnum.FLAT_ROOF + + +freeform = IfcRoofTypeEnum.FREEFORM + + +gable_roof = IfcRoofTypeEnum.GABLE_ROOF + + +gambrel_roof = IfcRoofTypeEnum.GAMBREL_ROOF + + +hipped_gable_roof = IfcRoofTypeEnum.HIPPED_GABLE_ROOF + + +hip_roof = IfcRoofTypeEnum.HIP_ROOF + + +mansard_roof = IfcRoofTypeEnum.MANSARD_ROOF + + +pavilion_roof = IfcRoofTypeEnum.PAVILION_ROOF + + +rainbow_roof = IfcRoofTypeEnum.RAINBOW_ROOF + + +shed_roof = IfcRoofTypeEnum.SHED_ROOF + + +userdefined = IfcRoofTypeEnum.USERDEFINED + + +notdefined = IfcRoofTypeEnum.NOTDEFINED + + +IfcSIPrefix = enum_namespace() + + +atto = IfcSIPrefix.ATTO + + +centi = IfcSIPrefix.CENTI + + +deca = IfcSIPrefix.DECA + + +deci = IfcSIPrefix.DECI + + +exa = IfcSIPrefix.EXA + + +femto = IfcSIPrefix.FEMTO + + +giga = IfcSIPrefix.GIGA + + +hecto = IfcSIPrefix.HECTO + + +kilo = IfcSIPrefix.KILO + + +mega = IfcSIPrefix.MEGA + + +micro = IfcSIPrefix.MICRO + + +milli = IfcSIPrefix.MILLI + + +nano = IfcSIPrefix.NANO + + +peta = IfcSIPrefix.PETA + + +pico = IfcSIPrefix.PICO + + +tera = IfcSIPrefix.TERA + + +IfcSIUnitName = enum_namespace() + + +ampere = IfcSIUnitName.AMPERE + + +becquerel = IfcSIUnitName.BECQUEREL + + +candela = IfcSIUnitName.CANDELA + + +coulomb = IfcSIUnitName.COULOMB + + +cubic_metre = IfcSIUnitName.CUBIC_METRE + + +degree_celsius = IfcSIUnitName.DEGREE_CELSIUS + + +farad = IfcSIUnitName.FARAD + + +gram = IfcSIUnitName.GRAM + + +gray = IfcSIUnitName.GRAY + + +henry = IfcSIUnitName.HENRY + + +hertz = IfcSIUnitName.HERTZ + + +joule = IfcSIUnitName.JOULE + + +kelvin = IfcSIUnitName.KELVIN + + +lumen = IfcSIUnitName.LUMEN + + +lux = IfcSIUnitName.LUX + + +metre = IfcSIUnitName.METRE + + +mole = IfcSIUnitName.MOLE + + +newton = IfcSIUnitName.NEWTON + + +ohm = IfcSIUnitName.OHM + + +pascal = IfcSIUnitName.PASCAL + + +radian = IfcSIUnitName.RADIAN + + +second = IfcSIUnitName.SECOND + + +siemens = IfcSIUnitName.SIEMENS + + +sievert = IfcSIUnitName.SIEVERT + + +square_metre = IfcSIUnitName.SQUARE_METRE + + +steradian = IfcSIUnitName.STERADIAN + + +tesla = IfcSIUnitName.TESLA + + +volt = IfcSIUnitName.VOLT + + +watt = IfcSIUnitName.WATT + + +weber = IfcSIUnitName.WEBER + + +IfcSanitaryTerminalTypeEnum = enum_namespace() + + +bath = IfcSanitaryTerminalTypeEnum.BATH + + +bidet = IfcSanitaryTerminalTypeEnum.BIDET + + +cistern = IfcSanitaryTerminalTypeEnum.CISTERN + + +sanitaryfountain = IfcSanitaryTerminalTypeEnum.SANITARYFOUNTAIN + + +shower = IfcSanitaryTerminalTypeEnum.SHOWER + + +sink = IfcSanitaryTerminalTypeEnum.SINK + + +toiletpan = IfcSanitaryTerminalTypeEnum.TOILETPAN + + +urinal = IfcSanitaryTerminalTypeEnum.URINAL + + +washhandbasin = IfcSanitaryTerminalTypeEnum.WASHHANDBASIN + + +wcseat = IfcSanitaryTerminalTypeEnum.WCSEAT + + +userdefined = IfcSanitaryTerminalTypeEnum.USERDEFINED + + +notdefined = IfcSanitaryTerminalTypeEnum.NOTDEFINED + + +IfcSectionTypeEnum = enum_namespace() + + +tapered = IfcSectionTypeEnum.TAPERED + + +uniform = IfcSectionTypeEnum.UNIFORM + + +IfcSensorTypeEnum = enum_namespace() + + +co2sensor = IfcSensorTypeEnum.CO2SENSOR + + +conductancesensor = IfcSensorTypeEnum.CONDUCTANCESENSOR + + +contactsensor = IfcSensorTypeEnum.CONTACTSENSOR + + +cosensor = IfcSensorTypeEnum.COSENSOR + + +earthquakesensor = IfcSensorTypeEnum.EARTHQUAKESENSOR + + +firesensor = IfcSensorTypeEnum.FIRESENSOR + + +flowsensor = IfcSensorTypeEnum.FLOWSENSOR + + +foreignobjectdetectionsensor = IfcSensorTypeEnum.FOREIGNOBJECTDETECTIONSENSOR + + +frostsensor = IfcSensorTypeEnum.FROSTSENSOR + + +gassensor = IfcSensorTypeEnum.GASSENSOR + + +heatsensor = IfcSensorTypeEnum.HEATSENSOR + + +humiditysensor = IfcSensorTypeEnum.HUMIDITYSENSOR + + +identifiersensor = IfcSensorTypeEnum.IDENTIFIERSENSOR + + +ionconcentrationsensor = IfcSensorTypeEnum.IONCONCENTRATIONSENSOR + + +levelsensor = IfcSensorTypeEnum.LEVELSENSOR + + +lightsensor = IfcSensorTypeEnum.LIGHTSENSOR + + +moisturesensor = IfcSensorTypeEnum.MOISTURESENSOR + + +movementsensor = IfcSensorTypeEnum.MOVEMENTSENSOR + + +obstaclesensor = IfcSensorTypeEnum.OBSTACLESENSOR + + +phsensor = IfcSensorTypeEnum.PHSENSOR + + +pressuresensor = IfcSensorTypeEnum.PRESSURESENSOR + + +radiationsensor = IfcSensorTypeEnum.RADIATIONSENSOR + + +radioactivitysensor = IfcSensorTypeEnum.RADIOACTIVITYSENSOR + + +rainsensor = IfcSensorTypeEnum.RAINSENSOR + + +smokesensor = IfcSensorTypeEnum.SMOKESENSOR + + +snowdepthsensor = IfcSensorTypeEnum.SNOWDEPTHSENSOR + + +soundsensor = IfcSensorTypeEnum.SOUNDSENSOR + + +temperaturesensor = IfcSensorTypeEnum.TEMPERATURESENSOR + + +trainsensor = IfcSensorTypeEnum.TRAINSENSOR + + +turnoutclosuresensor = IfcSensorTypeEnum.TURNOUTCLOSURESENSOR + + +wheelsensor = IfcSensorTypeEnum.WHEELSENSOR + + +windsensor = IfcSensorTypeEnum.WINDSENSOR + + +userdefined = IfcSensorTypeEnum.USERDEFINED + + +notdefined = IfcSensorTypeEnum.NOTDEFINED + + +IfcSequenceEnum = enum_namespace() + + +finish_finish = IfcSequenceEnum.FINISH_FINISH + + +finish_start = IfcSequenceEnum.FINISH_START + + +start_finish = IfcSequenceEnum.START_FINISH + + +start_start = IfcSequenceEnum.START_START + + +userdefined = IfcSequenceEnum.USERDEFINED + + +notdefined = IfcSequenceEnum.NOTDEFINED + + +IfcShadingDeviceTypeEnum = enum_namespace() + + +awning = IfcShadingDeviceTypeEnum.AWNING + + +jalousie = IfcShadingDeviceTypeEnum.JALOUSIE + + +shutter = IfcShadingDeviceTypeEnum.SHUTTER + + +userdefined = IfcShadingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcShadingDeviceTypeEnum.NOTDEFINED + + +IfcSignTypeEnum = enum_namespace() + + +marker = IfcSignTypeEnum.MARKER + + +mirror = IfcSignTypeEnum.MIRROR + + +pictoral = IfcSignTypeEnum.PICTORAL + + +userdefined = IfcSignTypeEnum.USERDEFINED + + +notdefined = IfcSignTypeEnum.NOTDEFINED + + +IfcSignalTypeEnum = enum_namespace() + + +audio = IfcSignalTypeEnum.AUDIO + + +mixed = IfcSignalTypeEnum.MIXED + + +visual = IfcSignalTypeEnum.VISUAL + + +userdefined = IfcSignalTypeEnum.USERDEFINED + + +notdefined = IfcSignalTypeEnum.NOTDEFINED + + +IfcSimplePropertyTemplateTypeEnum = enum_namespace() + + +p_boundedvalue = IfcSimplePropertyTemplateTypeEnum.P_BOUNDEDVALUE + + +p_enumeratedvalue = IfcSimplePropertyTemplateTypeEnum.P_ENUMERATEDVALUE + + +p_listvalue = IfcSimplePropertyTemplateTypeEnum.P_LISTVALUE + + +p_referencevalue = IfcSimplePropertyTemplateTypeEnum.P_REFERENCEVALUE + + +p_singlevalue = IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE + + +p_tablevalue = IfcSimplePropertyTemplateTypeEnum.P_TABLEVALUE + + +q_area = IfcSimplePropertyTemplateTypeEnum.Q_AREA + + +q_count = IfcSimplePropertyTemplateTypeEnum.Q_COUNT + + +q_length = IfcSimplePropertyTemplateTypeEnum.Q_LENGTH + + +q_number = IfcSimplePropertyTemplateTypeEnum.Q_NUMBER + + +q_time = IfcSimplePropertyTemplateTypeEnum.Q_TIME + + +q_volume = IfcSimplePropertyTemplateTypeEnum.Q_VOLUME + + +q_weight = IfcSimplePropertyTemplateTypeEnum.Q_WEIGHT + + +IfcSlabTypeEnum = enum_namespace() + + +approach_slab = IfcSlabTypeEnum.APPROACH_SLAB + + +baseslab = IfcSlabTypeEnum.BASESLAB + + +floor = IfcSlabTypeEnum.FLOOR + + +landing = IfcSlabTypeEnum.LANDING + + +paving = IfcSlabTypeEnum.PAVING + + +roof = IfcSlabTypeEnum.ROOF + + +sidewalk = IfcSlabTypeEnum.SIDEWALK + + +trackslab = IfcSlabTypeEnum.TRACKSLAB + + +wearing = IfcSlabTypeEnum.WEARING + + +userdefined = IfcSlabTypeEnum.USERDEFINED + + +notdefined = IfcSlabTypeEnum.NOTDEFINED + + +IfcSolarDeviceTypeEnum = enum_namespace() + + +solarcollector = IfcSolarDeviceTypeEnum.SOLARCOLLECTOR + + +solarpanel = IfcSolarDeviceTypeEnum.SOLARPANEL + + +userdefined = IfcSolarDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSolarDeviceTypeEnum.NOTDEFINED + + +IfcSpaceHeaterTypeEnum = enum_namespace() + + +convector = IfcSpaceHeaterTypeEnum.CONVECTOR + + +radiator = IfcSpaceHeaterTypeEnum.RADIATOR + + +userdefined = IfcSpaceHeaterTypeEnum.USERDEFINED + + +notdefined = IfcSpaceHeaterTypeEnum.NOTDEFINED + + +IfcSpaceTypeEnum = enum_namespace() + + +berth = IfcSpaceTypeEnum.BERTH + + +external = IfcSpaceTypeEnum.EXTERNAL + + +gfa = IfcSpaceTypeEnum.GFA + + +internal = IfcSpaceTypeEnum.INTERNAL + + +parking = IfcSpaceTypeEnum.PARKING + + +space = IfcSpaceTypeEnum.SPACE + + +userdefined = IfcSpaceTypeEnum.USERDEFINED + + +notdefined = IfcSpaceTypeEnum.NOTDEFINED + + +IfcSpatialZoneTypeEnum = enum_namespace() + + +construction = IfcSpatialZoneTypeEnum.CONSTRUCTION + + +firesafety = IfcSpatialZoneTypeEnum.FIRESAFETY + + +interference = IfcSpatialZoneTypeEnum.INTERFERENCE + + +lighting = IfcSpatialZoneTypeEnum.LIGHTING + + +occupancy = IfcSpatialZoneTypeEnum.OCCUPANCY + + +reservation = IfcSpatialZoneTypeEnum.RESERVATION + + +security = IfcSpatialZoneTypeEnum.SECURITY + + +thermal = IfcSpatialZoneTypeEnum.THERMAL + + +transport = IfcSpatialZoneTypeEnum.TRANSPORT + + +ventilation = IfcSpatialZoneTypeEnum.VENTILATION + + +userdefined = IfcSpatialZoneTypeEnum.USERDEFINED + + +notdefined = IfcSpatialZoneTypeEnum.NOTDEFINED + + +IfcStackTerminalTypeEnum = enum_namespace() + + +birdcage = IfcStackTerminalTypeEnum.BIRDCAGE + + +cowl = IfcStackTerminalTypeEnum.COWL + + +rainwaterhopper = IfcStackTerminalTypeEnum.RAINWATERHOPPER + + +userdefined = IfcStackTerminalTypeEnum.USERDEFINED + + +notdefined = IfcStackTerminalTypeEnum.NOTDEFINED + + +IfcStairFlightTypeEnum = enum_namespace() + + +curved = IfcStairFlightTypeEnum.CURVED + + +freeform = IfcStairFlightTypeEnum.FREEFORM + + +spiral = IfcStairFlightTypeEnum.SPIRAL + + +straight = IfcStairFlightTypeEnum.STRAIGHT + + +winder = IfcStairFlightTypeEnum.WINDER + + +userdefined = IfcStairFlightTypeEnum.USERDEFINED + + +notdefined = IfcStairFlightTypeEnum.NOTDEFINED + + +IfcStairTypeEnum = enum_namespace() + + +curved_run_stair = IfcStairTypeEnum.CURVED_RUN_STAIR + + +double_return_stair = IfcStairTypeEnum.DOUBLE_RETURN_STAIR + + +half_turn_stair = IfcStairTypeEnum.HALF_TURN_STAIR + + +half_winding_stair = IfcStairTypeEnum.HALF_WINDING_STAIR + + +ladder = IfcStairTypeEnum.LADDER + + +quarter_turn_stair = IfcStairTypeEnum.QUARTER_TURN_STAIR + + +quarter_winding_stair = IfcStairTypeEnum.QUARTER_WINDING_STAIR + + +spiral_stair = IfcStairTypeEnum.SPIRAL_STAIR + + +straight_run_stair = IfcStairTypeEnum.STRAIGHT_RUN_STAIR + + +three_quarter_turn_stair = IfcStairTypeEnum.THREE_QUARTER_TURN_STAIR + + +three_quarter_winding_stair = IfcStairTypeEnum.THREE_QUARTER_WINDING_STAIR + + +two_curved_run_stair = IfcStairTypeEnum.TWO_CURVED_RUN_STAIR + + +two_quarter_turn_stair = IfcStairTypeEnum.TWO_QUARTER_TURN_STAIR + + +two_quarter_winding_stair = IfcStairTypeEnum.TWO_QUARTER_WINDING_STAIR + + +two_straight_run_stair = IfcStairTypeEnum.TWO_STRAIGHT_RUN_STAIR + + +userdefined = IfcStairTypeEnum.USERDEFINED + + +notdefined = IfcStairTypeEnum.NOTDEFINED + + +IfcStateEnum = enum_namespace() + + +locked = IfcStateEnum.LOCKED + + +readonly = IfcStateEnum.READONLY + + +readonlylocked = IfcStateEnum.READONLYLOCKED + + +readwrite = IfcStateEnum.READWRITE + + +readwritelocked = IfcStateEnum.READWRITELOCKED + + +IfcStructuralCurveActivityTypeEnum = enum_namespace() + + +const = IfcStructuralCurveActivityTypeEnum.CONST + + +discrete = IfcStructuralCurveActivityTypeEnum.DISCRETE + + +equidistant = IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + +linear = IfcStructuralCurveActivityTypeEnum.LINEAR + + +parabola = IfcStructuralCurveActivityTypeEnum.PARABOLA + + +polygonal = IfcStructuralCurveActivityTypeEnum.POLYGONAL + + +sinus = IfcStructuralCurveActivityTypeEnum.SINUS + + +userdefined = IfcStructuralCurveActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveActivityTypeEnum.NOTDEFINED + + +IfcStructuralCurveMemberTypeEnum = enum_namespace() + + +cable = IfcStructuralCurveMemberTypeEnum.CABLE + + +compression_member = IfcStructuralCurveMemberTypeEnum.COMPRESSION_MEMBER + + +pin_joined_member = IfcStructuralCurveMemberTypeEnum.PIN_JOINED_MEMBER + + +rigid_joined_member = IfcStructuralCurveMemberTypeEnum.RIGID_JOINED_MEMBER + + +tension_member = IfcStructuralCurveMemberTypeEnum.TENSION_MEMBER + + +userdefined = IfcStructuralCurveMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralCurveMemberTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceActivityTypeEnum = enum_namespace() + + +bilinear = IfcStructuralSurfaceActivityTypeEnum.BILINEAR + + +const = IfcStructuralSurfaceActivityTypeEnum.CONST + + +discrete = IfcStructuralSurfaceActivityTypeEnum.DISCRETE + + +isocontour = IfcStructuralSurfaceActivityTypeEnum.ISOCONTOUR + + +userdefined = IfcStructuralSurfaceActivityTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceActivityTypeEnum.NOTDEFINED + + +IfcStructuralSurfaceMemberTypeEnum = enum_namespace() + + +bending_element = IfcStructuralSurfaceMemberTypeEnum.BENDING_ELEMENT + + +membrane_element = IfcStructuralSurfaceMemberTypeEnum.MEMBRANE_ELEMENT + + +shell = IfcStructuralSurfaceMemberTypeEnum.SHELL + + +userdefined = IfcStructuralSurfaceMemberTypeEnum.USERDEFINED + + +notdefined = IfcStructuralSurfaceMemberTypeEnum.NOTDEFINED + + +IfcSubContractResourceTypeEnum = enum_namespace() + + +purchase = IfcSubContractResourceTypeEnum.PURCHASE + + +work = IfcSubContractResourceTypeEnum.WORK + + +userdefined = IfcSubContractResourceTypeEnum.USERDEFINED + + +notdefined = IfcSubContractResourceTypeEnum.NOTDEFINED + + +IfcSurfaceFeatureTypeEnum = enum_namespace() + + +defect = IfcSurfaceFeatureTypeEnum.DEFECT + + +hatchmarking = IfcSurfaceFeatureTypeEnum.HATCHMARKING + + +linemarking = IfcSurfaceFeatureTypeEnum.LINEMARKING + + +mark = IfcSurfaceFeatureTypeEnum.MARK + + +nonskidsurfacing = IfcSurfaceFeatureTypeEnum.NONSKIDSURFACING + + +pavementsurfacemarking = IfcSurfaceFeatureTypeEnum.PAVEMENTSURFACEMARKING + + +rumblestrip = IfcSurfaceFeatureTypeEnum.RUMBLESTRIP + + +symbolmarking = IfcSurfaceFeatureTypeEnum.SYMBOLMARKING + + +tag = IfcSurfaceFeatureTypeEnum.TAG + + +transverserumblestrip = IfcSurfaceFeatureTypeEnum.TRANSVERSERUMBLESTRIP + + +treatment = IfcSurfaceFeatureTypeEnum.TREATMENT + + +userdefined = IfcSurfaceFeatureTypeEnum.USERDEFINED + + +notdefined = IfcSurfaceFeatureTypeEnum.NOTDEFINED + + +IfcSurfaceSide = enum_namespace() + + +both = IfcSurfaceSide.BOTH + + +negative = IfcSurfaceSide.NEGATIVE + + +positive = IfcSurfaceSide.POSITIVE + + +IfcSwitchingDeviceTypeEnum = enum_namespace() + + +contactor = IfcSwitchingDeviceTypeEnum.CONTACTOR + + +dimmerswitch = IfcSwitchingDeviceTypeEnum.DIMMERSWITCH + + +emergencystop = IfcSwitchingDeviceTypeEnum.EMERGENCYSTOP + + +keypad = IfcSwitchingDeviceTypeEnum.KEYPAD + + +momentaryswitch = IfcSwitchingDeviceTypeEnum.MOMENTARYSWITCH + + +relay = IfcSwitchingDeviceTypeEnum.RELAY + + +selectorswitch = IfcSwitchingDeviceTypeEnum.SELECTORSWITCH + + +starter = IfcSwitchingDeviceTypeEnum.STARTER + + +start_and_stop_equipment = IfcSwitchingDeviceTypeEnum.START_AND_STOP_EQUIPMENT + + +switchdisconnector = IfcSwitchingDeviceTypeEnum.SWITCHDISCONNECTOR + + +toggleswitch = IfcSwitchingDeviceTypeEnum.TOGGLESWITCH + + +userdefined = IfcSwitchingDeviceTypeEnum.USERDEFINED + + +notdefined = IfcSwitchingDeviceTypeEnum.NOTDEFINED + + +IfcSystemFurnitureElementTypeEnum = enum_namespace() + + +panel = IfcSystemFurnitureElementTypeEnum.PANEL + + +subrack = IfcSystemFurnitureElementTypeEnum.SUBRACK + + +worksurface = IfcSystemFurnitureElementTypeEnum.WORKSURFACE + + +userdefined = IfcSystemFurnitureElementTypeEnum.USERDEFINED + + +notdefined = IfcSystemFurnitureElementTypeEnum.NOTDEFINED + + +IfcTankTypeEnum = enum_namespace() + + +basin = IfcTankTypeEnum.BASIN + + +breakpressure = IfcTankTypeEnum.BREAKPRESSURE + + +expansion = IfcTankTypeEnum.EXPANSION + + +feedandexpansion = IfcTankTypeEnum.FEEDANDEXPANSION + + +oilretentiontray = IfcTankTypeEnum.OILRETENTIONTRAY + + +pressurevessel = IfcTankTypeEnum.PRESSUREVESSEL + + +storage = IfcTankTypeEnum.STORAGE + + +vessel = IfcTankTypeEnum.VESSEL + + +userdefined = IfcTankTypeEnum.USERDEFINED + + +notdefined = IfcTankTypeEnum.NOTDEFINED + + +IfcTaskDurationEnum = enum_namespace() + + +elapsedtime = IfcTaskDurationEnum.ELAPSEDTIME + + +worktime = IfcTaskDurationEnum.WORKTIME + + +notdefined = IfcTaskDurationEnum.NOTDEFINED + + +IfcTaskTypeEnum = enum_namespace() + + +adjustment = IfcTaskTypeEnum.ADJUSTMENT + + +attendance = IfcTaskTypeEnum.ATTENDANCE + + +calibration = IfcTaskTypeEnum.CALIBRATION + + +construction = IfcTaskTypeEnum.CONSTRUCTION + + +demolition = IfcTaskTypeEnum.DEMOLITION + + +dismantle = IfcTaskTypeEnum.DISMANTLE + + +disposal = IfcTaskTypeEnum.DISPOSAL + + +emergency = IfcTaskTypeEnum.EMERGENCY + + +inspection = IfcTaskTypeEnum.INSPECTION + + +installation = IfcTaskTypeEnum.INSTALLATION + + +logistic = IfcTaskTypeEnum.LOGISTIC + + +maintenance = IfcTaskTypeEnum.MAINTENANCE + + +move = IfcTaskTypeEnum.MOVE + + +operation = IfcTaskTypeEnum.OPERATION + + +removal = IfcTaskTypeEnum.REMOVAL + + +renovation = IfcTaskTypeEnum.RENOVATION + + +safety = IfcTaskTypeEnum.SAFETY + + +shutdown = IfcTaskTypeEnum.SHUTDOWN + + +startup = IfcTaskTypeEnum.STARTUP + + +testing = IfcTaskTypeEnum.TESTING + + +troubleshooting = IfcTaskTypeEnum.TROUBLESHOOTING + + +userdefined = IfcTaskTypeEnum.USERDEFINED + + +notdefined = IfcTaskTypeEnum.NOTDEFINED + + +IfcTendonAnchorTypeEnum = enum_namespace() + + +coupler = IfcTendonAnchorTypeEnum.COUPLER + + +fixed_end = IfcTendonAnchorTypeEnum.FIXED_END + + +tensioning_end = IfcTendonAnchorTypeEnum.TENSIONING_END + + +userdefined = IfcTendonAnchorTypeEnum.USERDEFINED + + +notdefined = IfcTendonAnchorTypeEnum.NOTDEFINED + + +IfcTendonConduitTypeEnum = enum_namespace() + + +coupler = IfcTendonConduitTypeEnum.COUPLER + + +diabolo = IfcTendonConduitTypeEnum.DIABOLO + + +duct = IfcTendonConduitTypeEnum.DUCT + + +grouting_duct = IfcTendonConduitTypeEnum.GROUTING_DUCT + + +trumpet = IfcTendonConduitTypeEnum.TRUMPET + + +userdefined = IfcTendonConduitTypeEnum.USERDEFINED + + +notdefined = IfcTendonConduitTypeEnum.NOTDEFINED + + +IfcTendonTypeEnum = enum_namespace() + + +bar = IfcTendonTypeEnum.BAR + + +coated = IfcTendonTypeEnum.COATED + + +strand = IfcTendonTypeEnum.STRAND + + +wire = IfcTendonTypeEnum.WIRE + + +userdefined = IfcTendonTypeEnum.USERDEFINED + + +notdefined = IfcTendonTypeEnum.NOTDEFINED + + +IfcTextPath = enum_namespace() + + +down = IfcTextPath.DOWN + + +left = IfcTextPath.LEFT + + +right = IfcTextPath.RIGHT + + +up = IfcTextPath.UP + + +IfcTimeSeriesDataTypeEnum = enum_namespace() + + +continuous = IfcTimeSeriesDataTypeEnum.CONTINUOUS + + +discrete = IfcTimeSeriesDataTypeEnum.DISCRETE + + +discretebinary = IfcTimeSeriesDataTypeEnum.DISCRETEBINARY + + +piecewisebinary = IfcTimeSeriesDataTypeEnum.PIECEWISEBINARY + + +piecewiseconstant = IfcTimeSeriesDataTypeEnum.PIECEWISECONSTANT + + +piecewisecontinuous = IfcTimeSeriesDataTypeEnum.PIECEWISECONTINUOUS + + +notdefined = IfcTimeSeriesDataTypeEnum.NOTDEFINED + + +IfcTrackElementTypeEnum = enum_namespace() + + +blockingdevice = IfcTrackElementTypeEnum.BLOCKINGDEVICE + + +derailer = IfcTrackElementTypeEnum.DERAILER + + +frog = IfcTrackElementTypeEnum.FROG + + +half_set_of_blades = IfcTrackElementTypeEnum.HALF_SET_OF_BLADES + + +sleeper = IfcTrackElementTypeEnum.SLEEPER + + +speedregulator = IfcTrackElementTypeEnum.SPEEDREGULATOR + + +trackendofalignment = IfcTrackElementTypeEnum.TRACKENDOFALIGNMENT + + +vehiclestop = IfcTrackElementTypeEnum.VEHICLESTOP + + +userdefined = IfcTrackElementTypeEnum.USERDEFINED + + +notdefined = IfcTrackElementTypeEnum.NOTDEFINED + + +IfcTransformerTypeEnum = enum_namespace() + + +chopper = IfcTransformerTypeEnum.CHOPPER + + +combined = IfcTransformerTypeEnum.COMBINED + + +current = IfcTransformerTypeEnum.CURRENT + + +frequency = IfcTransformerTypeEnum.FREQUENCY + + +inverter = IfcTransformerTypeEnum.INVERTER + + +rectifier = IfcTransformerTypeEnum.RECTIFIER + + +voltage = IfcTransformerTypeEnum.VOLTAGE + + +userdefined = IfcTransformerTypeEnum.USERDEFINED + + +notdefined = IfcTransformerTypeEnum.NOTDEFINED + + +IfcTransitionCode = enum_namespace() + + +continuous = IfcTransitionCode.CONTINUOUS + + +contsamegradient = IfcTransitionCode.CONTSAMEGRADIENT + + +contsamegradientsamecurvature = IfcTransitionCode.CONTSAMEGRADIENTSAMECURVATURE + + +discontinuous = IfcTransitionCode.DISCONTINUOUS + + +IfcTransportElementTypeEnum = enum_namespace() + + +craneway = IfcTransportElementTypeEnum.CRANEWAY + + +elevator = IfcTransportElementTypeEnum.ELEVATOR + + +escalator = IfcTransportElementTypeEnum.ESCALATOR + + +haulinggear = IfcTransportElementTypeEnum.HAULINGGEAR + + +liftinggear = IfcTransportElementTypeEnum.LIFTINGGEAR + + +movingwalkway = IfcTransportElementTypeEnum.MOVINGWALKWAY + + +userdefined = IfcTransportElementTypeEnum.USERDEFINED + + +notdefined = IfcTransportElementTypeEnum.NOTDEFINED + + +IfcTrimmingPreference = enum_namespace() + + +cartesian = IfcTrimmingPreference.CARTESIAN + + +parameter = IfcTrimmingPreference.PARAMETER + + +unspecified = IfcTrimmingPreference.UNSPECIFIED + + +IfcTubeBundleTypeEnum = enum_namespace() + + +finned = IfcTubeBundleTypeEnum.FINNED + + +userdefined = IfcTubeBundleTypeEnum.USERDEFINED + + +notdefined = IfcTubeBundleTypeEnum.NOTDEFINED + + +IfcUnitEnum = enum_namespace() + + +absorbeddoseunit = IfcUnitEnum.ABSORBEDDOSEUNIT + + +amountofsubstanceunit = IfcUnitEnum.AMOUNTOFSUBSTANCEUNIT + + +areaunit = IfcUnitEnum.AREAUNIT + + +doseequivalentunit = IfcUnitEnum.DOSEEQUIVALENTUNIT + + +electriccapacitanceunit = IfcUnitEnum.ELECTRICCAPACITANCEUNIT + + +electricchargeunit = IfcUnitEnum.ELECTRICCHARGEUNIT + + +electricconductanceunit = IfcUnitEnum.ELECTRICCONDUCTANCEUNIT + + +electriccurrentunit = IfcUnitEnum.ELECTRICCURRENTUNIT + + +electricresistanceunit = IfcUnitEnum.ELECTRICRESISTANCEUNIT + + +electricvoltageunit = IfcUnitEnum.ELECTRICVOLTAGEUNIT + + +energyunit = IfcUnitEnum.ENERGYUNIT + + +forceunit = IfcUnitEnum.FORCEUNIT + + +frequencyunit = IfcUnitEnum.FREQUENCYUNIT + + +illuminanceunit = IfcUnitEnum.ILLUMINANCEUNIT + + +inductanceunit = IfcUnitEnum.INDUCTANCEUNIT + + +lengthunit = IfcUnitEnum.LENGTHUNIT + + +luminousfluxunit = IfcUnitEnum.LUMINOUSFLUXUNIT + + +luminousintensityunit = IfcUnitEnum.LUMINOUSINTENSITYUNIT + + +magneticfluxdensityunit = IfcUnitEnum.MAGNETICFLUXDENSITYUNIT + + +magneticfluxunit = IfcUnitEnum.MAGNETICFLUXUNIT + + +massunit = IfcUnitEnum.MASSUNIT + + +planeangleunit = IfcUnitEnum.PLANEANGLEUNIT + + +powerunit = IfcUnitEnum.POWERUNIT + + +pressureunit = IfcUnitEnum.PRESSUREUNIT + + +radioactivityunit = IfcUnitEnum.RADIOACTIVITYUNIT + + +solidangleunit = IfcUnitEnum.SOLIDANGLEUNIT + + +thermodynamictemperatureunit = IfcUnitEnum.THERMODYNAMICTEMPERATUREUNIT + + +timeunit = IfcUnitEnum.TIMEUNIT + + +volumeunit = IfcUnitEnum.VOLUMEUNIT + + +userdefined = IfcUnitEnum.USERDEFINED + + +IfcUnitaryControlElementTypeEnum = enum_namespace() + + +alarmpanel = IfcUnitaryControlElementTypeEnum.ALARMPANEL + + +basestationcontroller = IfcUnitaryControlElementTypeEnum.BASESTATIONCONTROLLER + + +combined = IfcUnitaryControlElementTypeEnum.COMBINED + + +controlpanel = IfcUnitaryControlElementTypeEnum.CONTROLPANEL + + +gasdetectionpanel = IfcUnitaryControlElementTypeEnum.GASDETECTIONPANEL + + +humidistat = IfcUnitaryControlElementTypeEnum.HUMIDISTAT + + +indicatorpanel = IfcUnitaryControlElementTypeEnum.INDICATORPANEL + + +mimicpanel = IfcUnitaryControlElementTypeEnum.MIMICPANEL + + +thermostat = IfcUnitaryControlElementTypeEnum.THERMOSTAT + + +weatherstation = IfcUnitaryControlElementTypeEnum.WEATHERSTATION + + +userdefined = IfcUnitaryControlElementTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryControlElementTypeEnum.NOTDEFINED + + +IfcUnitaryEquipmentTypeEnum = enum_namespace() + + +airconditioningunit = IfcUnitaryEquipmentTypeEnum.AIRCONDITIONINGUNIT + + +airhandler = IfcUnitaryEquipmentTypeEnum.AIRHANDLER + + +dehumidifier = IfcUnitaryEquipmentTypeEnum.DEHUMIDIFIER + + +rooftopunit = IfcUnitaryEquipmentTypeEnum.ROOFTOPUNIT + + +splitsystem = IfcUnitaryEquipmentTypeEnum.SPLITSYSTEM + + +userdefined = IfcUnitaryEquipmentTypeEnum.USERDEFINED + + +notdefined = IfcUnitaryEquipmentTypeEnum.NOTDEFINED + + +IfcValveTypeEnum = enum_namespace() + + +airrelease = IfcValveTypeEnum.AIRRELEASE + + +antivacuum = IfcValveTypeEnum.ANTIVACUUM + + +changeover = IfcValveTypeEnum.CHANGEOVER + + +check = IfcValveTypeEnum.CHECK + + +commissioning = IfcValveTypeEnum.COMMISSIONING + + +diverting = IfcValveTypeEnum.DIVERTING + + +doublecheck = IfcValveTypeEnum.DOUBLECHECK + + +doubleregulating = IfcValveTypeEnum.DOUBLEREGULATING + + +drawoffcock = IfcValveTypeEnum.DRAWOFFCOCK + + +faucet = IfcValveTypeEnum.FAUCET + + +flushing = IfcValveTypeEnum.FLUSHING + + +gascock = IfcValveTypeEnum.GASCOCK + + +gastap = IfcValveTypeEnum.GASTAP + + +isolating = IfcValveTypeEnum.ISOLATING + + +mixing = IfcValveTypeEnum.MIXING + + +pressurereducing = IfcValveTypeEnum.PRESSUREREDUCING + + +pressurerelief = IfcValveTypeEnum.PRESSURERELIEF + + +regulating = IfcValveTypeEnum.REGULATING + + +safetycutoff = IfcValveTypeEnum.SAFETYCUTOFF + + +steamtrap = IfcValveTypeEnum.STEAMTRAP + + +stopcock = IfcValveTypeEnum.STOPCOCK + + +userdefined = IfcValveTypeEnum.USERDEFINED + + +notdefined = IfcValveTypeEnum.NOTDEFINED + + +IfcVehicleTypeEnum = enum_namespace() + + +cargo = IfcVehicleTypeEnum.CARGO + + +rollingstock = IfcVehicleTypeEnum.ROLLINGSTOCK + + +vehicle = IfcVehicleTypeEnum.VEHICLE + + +vehicleair = IfcVehicleTypeEnum.VEHICLEAIR + + +vehiclemarine = IfcVehicleTypeEnum.VEHICLEMARINE + + +vehicletracked = IfcVehicleTypeEnum.VEHICLETRACKED + + +vehiclewheeled = IfcVehicleTypeEnum.VEHICLEWHEELED + + +userdefined = IfcVehicleTypeEnum.USERDEFINED + + +notdefined = IfcVehicleTypeEnum.NOTDEFINED + + +IfcVibrationDamperTypeEnum = enum_namespace() + + +axial_yield = IfcVibrationDamperTypeEnum.AXIAL_YIELD + + +bending_yield = IfcVibrationDamperTypeEnum.BENDING_YIELD + + +friction = IfcVibrationDamperTypeEnum.FRICTION + + +rubber = IfcVibrationDamperTypeEnum.RUBBER + + +shear_yield = IfcVibrationDamperTypeEnum.SHEAR_YIELD + + +viscous = IfcVibrationDamperTypeEnum.VISCOUS + + +userdefined = IfcVibrationDamperTypeEnum.USERDEFINED + + +notdefined = IfcVibrationDamperTypeEnum.NOTDEFINED + + +IfcVibrationIsolatorTypeEnum = enum_namespace() + + +base = IfcVibrationIsolatorTypeEnum.BASE + + +compression = IfcVibrationIsolatorTypeEnum.COMPRESSION + + +spring = IfcVibrationIsolatorTypeEnum.SPRING + + +userdefined = IfcVibrationIsolatorTypeEnum.USERDEFINED + + +notdefined = IfcVibrationIsolatorTypeEnum.NOTDEFINED + + +IfcVirtualElementTypeEnum = enum_namespace() + + +boundary = IfcVirtualElementTypeEnum.BOUNDARY + + +clearance = IfcVirtualElementTypeEnum.CLEARANCE + + +provisionforvoid = IfcVirtualElementTypeEnum.PROVISIONFORVOID + + +userdefined = IfcVirtualElementTypeEnum.USERDEFINED + + +notdefined = IfcVirtualElementTypeEnum.NOTDEFINED + + +IfcVoidingFeatureTypeEnum = enum_namespace() + + +chamfer = IfcVoidingFeatureTypeEnum.CHAMFER + + +cutout = IfcVoidingFeatureTypeEnum.CUTOUT + + +edge = IfcVoidingFeatureTypeEnum.EDGE + + +hole = IfcVoidingFeatureTypeEnum.HOLE + + +miter = IfcVoidingFeatureTypeEnum.MITER + + +notch = IfcVoidingFeatureTypeEnum.NOTCH + + +userdefined = IfcVoidingFeatureTypeEnum.USERDEFINED + + +notdefined = IfcVoidingFeatureTypeEnum.NOTDEFINED + + +IfcWallTypeEnum = enum_namespace() + + +elementedwall = IfcWallTypeEnum.ELEMENTEDWALL + + +movable = IfcWallTypeEnum.MOVABLE + + +parapet = IfcWallTypeEnum.PARAPET + + +partitioning = IfcWallTypeEnum.PARTITIONING + + +plumbingwall = IfcWallTypeEnum.PLUMBINGWALL + + +polygonal = IfcWallTypeEnum.POLYGONAL + + +retainingwall = IfcWallTypeEnum.RETAININGWALL + + +shear = IfcWallTypeEnum.SHEAR + + +solidwall = IfcWallTypeEnum.SOLIDWALL + + +standard = IfcWallTypeEnum.STANDARD + + +wavewall = IfcWallTypeEnum.WAVEWALL + + +userdefined = IfcWallTypeEnum.USERDEFINED + + +notdefined = IfcWallTypeEnum.NOTDEFINED + + +IfcWasteTerminalTypeEnum = enum_namespace() + + +floortrap = IfcWasteTerminalTypeEnum.FLOORTRAP + + +floorwaste = IfcWasteTerminalTypeEnum.FLOORWASTE + + +gullysump = IfcWasteTerminalTypeEnum.GULLYSUMP + + +gullytrap = IfcWasteTerminalTypeEnum.GULLYTRAP + + +roofdrain = IfcWasteTerminalTypeEnum.ROOFDRAIN + + +wastedisposalunit = IfcWasteTerminalTypeEnum.WASTEDISPOSALUNIT + + +wastetrap = IfcWasteTerminalTypeEnum.WASTETRAP + + +userdefined = IfcWasteTerminalTypeEnum.USERDEFINED + + +notdefined = IfcWasteTerminalTypeEnum.NOTDEFINED + + +IfcWindowPanelOperationEnum = enum_namespace() + + +bottomhung = IfcWindowPanelOperationEnum.BOTTOMHUNG + + +fixedcasement = IfcWindowPanelOperationEnum.FIXEDCASEMENT + + +otheroperation = IfcWindowPanelOperationEnum.OTHEROPERATION + + +pivothorizontal = IfcWindowPanelOperationEnum.PIVOTHORIZONTAL + + +pivotvertical = IfcWindowPanelOperationEnum.PIVOTVERTICAL + + +removablecasement = IfcWindowPanelOperationEnum.REMOVABLECASEMENT + + +sidehunglefthand = IfcWindowPanelOperationEnum.SIDEHUNGLEFTHAND + + +sidehungrighthand = IfcWindowPanelOperationEnum.SIDEHUNGRIGHTHAND + + +slidinghorizontal = IfcWindowPanelOperationEnum.SLIDINGHORIZONTAL + + +slidingvertical = IfcWindowPanelOperationEnum.SLIDINGVERTICAL + + +tiltandturnlefthand = IfcWindowPanelOperationEnum.TILTANDTURNLEFTHAND + + +tiltandturnrighthand = IfcWindowPanelOperationEnum.TILTANDTURNRIGHTHAND + + +tophung = IfcWindowPanelOperationEnum.TOPHUNG + + +notdefined = IfcWindowPanelOperationEnum.NOTDEFINED + + +IfcWindowPanelPositionEnum = enum_namespace() + + +bottom = IfcWindowPanelPositionEnum.BOTTOM + + +left = IfcWindowPanelPositionEnum.LEFT + + +middle = IfcWindowPanelPositionEnum.MIDDLE + + +right = IfcWindowPanelPositionEnum.RIGHT + + +top = IfcWindowPanelPositionEnum.TOP + + +notdefined = IfcWindowPanelPositionEnum.NOTDEFINED + + +IfcWindowTypeEnum = enum_namespace() + + +lightdome = IfcWindowTypeEnum.LIGHTDOME + + +skylight = IfcWindowTypeEnum.SKYLIGHT + + +window = IfcWindowTypeEnum.WINDOW + + +userdefined = IfcWindowTypeEnum.USERDEFINED + + +notdefined = IfcWindowTypeEnum.NOTDEFINED + + +IfcWindowTypePartitioningEnum = enum_namespace() + + +double_panel_horizontal = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_HORIZONTAL + + +double_panel_vertical = IfcWindowTypePartitioningEnum.DOUBLE_PANEL_VERTICAL + + +single_panel = IfcWindowTypePartitioningEnum.SINGLE_PANEL + + +triple_panel_bottom = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_BOTTOM + + +triple_panel_horizontal = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_HORIZONTAL + + +triple_panel_left = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_LEFT + + +triple_panel_right = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_RIGHT + + +triple_panel_top = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_TOP + + +triple_panel_vertical = IfcWindowTypePartitioningEnum.TRIPLE_PANEL_VERTICAL + + +userdefined = IfcWindowTypePartitioningEnum.USERDEFINED + + +notdefined = IfcWindowTypePartitioningEnum.NOTDEFINED + + +IfcWorkCalendarTypeEnum = enum_namespace() + + +firstshift = IfcWorkCalendarTypeEnum.FIRSTSHIFT + + +secondshift = IfcWorkCalendarTypeEnum.SECONDSHIFT + + +thirdshift = IfcWorkCalendarTypeEnum.THIRDSHIFT + + +userdefined = IfcWorkCalendarTypeEnum.USERDEFINED + + +notdefined = IfcWorkCalendarTypeEnum.NOTDEFINED + + +IfcWorkPlanTypeEnum = enum_namespace() + + +actual = IfcWorkPlanTypeEnum.ACTUAL + + +baseline = IfcWorkPlanTypeEnum.BASELINE + + +planned = IfcWorkPlanTypeEnum.PLANNED + + +userdefined = IfcWorkPlanTypeEnum.USERDEFINED + + +notdefined = IfcWorkPlanTypeEnum.NOTDEFINED + + +IfcWorkScheduleTypeEnum = enum_namespace() + + +actual = IfcWorkScheduleTypeEnum.ACTUAL + + +baseline = IfcWorkScheduleTypeEnum.BASELINE + + +planned = IfcWorkScheduleTypeEnum.PLANNED + + +userdefined = IfcWorkScheduleTypeEnum.USERDEFINED + + +notdefined = IfcWorkScheduleTypeEnum.NOTDEFINED + + +def IfcActionRequest(*args, **kwargs): return ifcopenshell.create_entity('IfcActionRequest', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcActor(*args, **kwargs): return ifcopenshell.create_entity('IfcActor', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcActorRole(*args, **kwargs): return ifcopenshell.create_entity('IfcActorRole', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcActuator(*args, **kwargs): return ifcopenshell.create_entity('IfcActuator', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcActuatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcActuatorType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcAddress', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAdvancedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrep', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAdvancedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedBrepWithVoids', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAdvancedFace(*args, **kwargs): return ifcopenshell.create_entity('IfcAdvancedFace', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAirTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminal', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAirTerminalBox(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBox', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAirTerminalBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalBoxType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAirTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirTerminalType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAirToAirHeatRecovery(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecovery', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAirToAirHeatRecoveryType(*args, **kwargs): return ifcopenshell.create_entity('IfcAirToAirHeatRecoveryType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAlarm(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarm', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAlarmType(*args, **kwargs): return ifcopenshell.create_entity('IfcAlarmType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAlignment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAlignmentCant(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCant', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAlignmentCantSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentCantSegment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAlignmentHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentHorizontal', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAlignmentHorizontalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentHorizontalSegment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAlignmentParameterSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentParameterSegment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAlignmentSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentSegment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAlignmentVertical(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentVertical', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAlignmentVerticalSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcAlignmentVerticalSegment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAnnotation(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotation', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAnnotationFillArea(*args, **kwargs): return ifcopenshell.create_entity('IfcAnnotationFillArea', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcApplication(*args, **kwargs): return ifcopenshell.create_entity('IfcApplication', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAppliedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcAppliedValue', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcApproval', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcApprovalRelationship', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcArbitraryClosedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryClosedProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcArbitraryOpenProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryOpenProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcArbitraryProfileDefWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcArbitraryProfileDefWithVoids', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAsset(*args, **kwargs): return ifcopenshell.create_entity('IfcAsset', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAsymmetricIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcAsymmetricIShapeProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAudioVisualAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualAppliance', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAudioVisualApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcAudioVisualApplianceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAxis1Placement(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis1Placement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAxis2Placement2D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement2D', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAxis2Placement3D(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2Placement3D', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcAxis2PlacementLinear(*args, **kwargs): return ifcopenshell.create_entity('IfcAxis2PlacementLinear', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBSplineCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineCurveWithKnots', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBSplineSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurface', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcBSplineSurfaceWithKnots', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcBeam', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcBeamType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBearing(*args, **kwargs): return ifcopenshell.create_entity('IfcBearing', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBearingType(*args, **kwargs): return ifcopenshell.create_entity('IfcBearingType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBlobTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcBlobTexture', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBlock(*args, **kwargs): return ifcopenshell.create_entity('IfcBlock', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBoiler(*args, **kwargs): return ifcopenshell.create_entity('IfcBoiler', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBoilerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBoilerType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBooleanClippingResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanClippingResult', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBooleanResult(*args, **kwargs): return ifcopenshell.create_entity('IfcBooleanResult', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBorehole(*args, **kwargs): return ifcopenshell.create_entity('IfcBorehole', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBoundaryCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCondition', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBoundaryEdgeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryEdgeCondition', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBoundaryFaceCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryFaceCondition', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBoundaryNodeCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeCondition', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBoundaryNodeConditionWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundaryNodeConditionWarping', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBoundedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundedSurface', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBoundingBox(*args, **kwargs): return ifcopenshell.create_entity('IfcBoundingBox', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBoxedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcBoxedHalfSpace', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBridge(*args, **kwargs): return ifcopenshell.create_entity('IfcBridge', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBridgePart(*args, **kwargs): return ifcopenshell.create_entity('IfcBridgePart', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBuilding(*args, **kwargs): return ifcopenshell.create_entity('IfcBuilding', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBuildingElementPart(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPart', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBuildingElementPartType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementPartType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBuildingElementProxy(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxy', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBuildingElementProxyType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingElementProxyType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBuildingStorey(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingStorey', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBuildingSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuildingSystem', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBuiltElement(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBuiltElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBuiltSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcBuiltSystem', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBurner(*args, **kwargs): return ifcopenshell.create_entity('IfcBurner', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcBurnerType(*args, **kwargs): return ifcopenshell.create_entity('IfcBurnerType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCShapeProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCableCarrierFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFitting', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCableCarrierFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierFittingType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCableCarrierSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCableCarrierSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableCarrierSegmentType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCableFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFitting', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCableFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableFittingType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCableSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCableSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcCableSegmentType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCaissonFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundation', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCaissonFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcCaissonFoundationType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCartesianPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPoint', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCartesianPointList(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCartesianPointList2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList2D', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCartesianPointList3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianPointList3D', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCartesianTransformationOperator(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCartesianTransformationOperator2D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2D', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCartesianTransformationOperator2DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator2DnonUniform', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCartesianTransformationOperator3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3D', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCartesianTransformationOperator3DnonUniform(*args, **kwargs): return ifcopenshell.create_entity('IfcCartesianTransformationOperator3DnonUniform', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCenterLineProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCenterLineProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcChiller(*args, **kwargs): return ifcopenshell.create_entity('IfcChiller', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcChillerType(*args, **kwargs): return ifcopenshell.create_entity('IfcChillerType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcChimney(*args, **kwargs): return ifcopenshell.create_entity('IfcChimney', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcChimneyType(*args, **kwargs): return ifcopenshell.create_entity('IfcChimneyType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCircle(*args, **kwargs): return ifcopenshell.create_entity('IfcCircle', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCircleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleHollowProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCircleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCircleProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCivilElement(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCivilElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcCivilElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcClassification', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcClassificationReference(*args, **kwargs): return ifcopenshell.create_entity('IfcClassificationReference', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcClosedShell(*args, **kwargs): return ifcopenshell.create_entity('IfcClosedShell', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcClothoid(*args, **kwargs): return ifcopenshell.create_entity('IfcClothoid', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCoil(*args, **kwargs): return ifcopenshell.create_entity('IfcCoil', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCoilType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoilType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcColourRgb(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgb', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcColourRgbList(*args, **kwargs): return ifcopenshell.create_entity('IfcColourRgbList', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcColourSpecification(*args, **kwargs): return ifcopenshell.create_entity('IfcColourSpecification', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcColumn', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcColumnType(*args, **kwargs): return ifcopenshell.create_entity('IfcColumnType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsAppliance', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCommunicationsApplianceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcComplexProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexProperty', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcComplexPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcComplexPropertyTemplate', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCompositeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCompositeCurveOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveOnSurface', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeCurveSegment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCompositeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcCompositeProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCompressor(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressor', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCompressorType(*args, **kwargs): return ifcopenshell.create_entity('IfcCompressorType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCondenser(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenser', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCondenserType(*args, **kwargs): return ifcopenshell.create_entity('IfcCondenserType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConic(*args, **kwargs): return ifcopenshell.create_entity('IfcConic', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConnectedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectedFaceSet', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConnectionCurveGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionCurveGeometry', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConnectionGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionGeometry', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConnectionPointEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointEccentricity', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConnectionPointGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionPointGeometry', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConnectionSurfaceGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionSurfaceGeometry', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConnectionVolumeGeometry(*args, **kwargs): return ifcopenshell.create_entity('IfcConnectionVolumeGeometry', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcConstraint', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConstructionEquipmentResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResource', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConstructionEquipmentResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionEquipmentResourceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConstructionMaterialResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResource', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConstructionMaterialResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionMaterialResourceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConstructionProductResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResource', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConstructionProductResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionProductResourceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConstructionResource(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResource', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConstructionResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcConstructionResourceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcContext(*args, **kwargs): return ifcopenshell.create_entity('IfcContext', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcContextDependentUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcContextDependentUnit', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcControl(*args, **kwargs): return ifcopenshell.create_entity('IfcControl', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcController(*args, **kwargs): return ifcopenshell.create_entity('IfcController', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcControllerType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConversionBasedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnit', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConversionBasedUnitWithOffset(*args, **kwargs): return ifcopenshell.create_entity('IfcConversionBasedUnitWithOffset', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConveyorSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcConveyorSegment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcConveyorSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcConveyorSegmentType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCooledBeam(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeam', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCooledBeamType(*args, **kwargs): return ifcopenshell.create_entity('IfcCooledBeamType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCoolingTower(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTower', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCoolingTowerType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoolingTowerType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCoordinateOperation(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateOperation', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCoordinateReferenceSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcCoordinateReferenceSystem', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCosineSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcCosineSpiral', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCostItem(*args, **kwargs): return ifcopenshell.create_entity('IfcCostItem', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCostSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcCostSchedule', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCostValue(*args, **kwargs): return ifcopenshell.create_entity('IfcCostValue', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCourse(*args, **kwargs): return ifcopenshell.create_entity('IfcCourse', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCourseType(*args, **kwargs): return ifcopenshell.create_entity('IfcCourseType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCovering(*args, **kwargs): return ifcopenshell.create_entity('IfcCovering', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCoveringType(*args, **kwargs): return ifcopenshell.create_entity('IfcCoveringType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCrewResource(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResource', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCrewResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcCrewResourceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCsgPrimitive3D(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgPrimitive3D', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCsgSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcCsgSolid', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCurrencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcCurrencyRelationship', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCurtainWall(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWall', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCurtainWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcCurtainWallType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCurveBoundedPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedPlane', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCurveBoundedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveBoundedSurface', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveSegment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCurveStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyle', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCurveStyleFont(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFont', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCurveStyleFontAndScaling(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontAndScaling', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCurveStyleFontPattern(*args, **kwargs): return ifcopenshell.create_entity('IfcCurveStyleFontPattern', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcCylindricalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcCylindricalSurface', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcDamper', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcDamperType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDeepFoundation(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundation', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDeepFoundationType(*args, **kwargs): return ifcopenshell.create_entity('IfcDeepFoundationType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDerivedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDerivedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnit', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDerivedUnitElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDerivedUnitElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDimensionalExponents(*args, **kwargs): return ifcopenshell.create_entity('IfcDimensionalExponents', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDirection(*args, **kwargs): return ifcopenshell.create_entity('IfcDirection', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDirectrixCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcDirectrixCurveSweptAreaSolid', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDirectrixDerivedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcDirectrixDerivedReferenceSweptAreaSolid', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDiscreteAccessory(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessory', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDiscreteAccessoryType(*args, **kwargs): return ifcopenshell.create_entity('IfcDiscreteAccessoryType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionBoard', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionBoardType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDistributionChamberElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDistributionChamberElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionChamberElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDistributionCircuit(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionCircuit', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDistributionControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDistributionControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionControlElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDistributionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDistributionElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDistributionFlowElement(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDistributionFlowElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionFlowElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDistributionPort(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionPort', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDistributionSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcDistributionSystem', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDocumentInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformation', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDocumentInformationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentInformationRelationship', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDocumentReference(*args, **kwargs): return ifcopenshell.create_entity('IfcDocumentReference', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDoor(*args, **kwargs): return ifcopenshell.create_entity('IfcDoor', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDoorLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorLiningProperties', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDoorPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorPanelProperties', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDoorType(*args, **kwargs): return ifcopenshell.create_entity('IfcDoorType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDraughtingPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedColour', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDraughtingPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcDraughtingPreDefinedCurveFont', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDuctFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFitting', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDuctFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctFittingType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDuctSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDuctSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSegmentType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDuctSilencer(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencer', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcDuctSilencerType(*args, **kwargs): return ifcopenshell.create_entity('IfcDuctSilencerType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEarthworksCut(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksCut', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEarthworksElement(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEarthworksFill(*args, **kwargs): return ifcopenshell.create_entity('IfcEarthworksFill', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcEdge', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEdgeCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEdgeLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcEdgeLoop', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElectricAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricAppliance', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElectricApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricApplianceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElectricDistributionBoard(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoard', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElectricDistributionBoardType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricDistributionBoardType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElectricFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDevice', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElectricFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowStorageDeviceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElectricFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowTreatmentDevice', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElectricFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricFlowTreatmentDeviceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElectricGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGenerator', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElectricGeneratorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricGeneratorType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElectricMotor(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotor', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElectricMotorType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricMotorType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElectricTimeControl(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControl', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElectricTimeControlType(*args, **kwargs): return ifcopenshell.create_entity('IfcElectricTimeControlType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElement(*args, **kwargs): return ifcopenshell.create_entity('IfcElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElementAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssembly', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElementAssemblyType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementAssemblyType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElementComponent(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponent', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElementComponentType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementComponentType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElementQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcElementQuantity', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcElementarySurface(*args, **kwargs): return ifcopenshell.create_entity('IfcElementarySurface', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEllipse(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipse', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEllipseProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcEllipseProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEnergyConversionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDevice', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEnergyConversionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcEnergyConversionDeviceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEngine(*args, **kwargs): return ifcopenshell.create_entity('IfcEngine', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEngineType(*args, **kwargs): return ifcopenshell.create_entity('IfcEngineType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEvaporativeCooler(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCooler', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEvaporativeCoolerType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporativeCoolerType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEvaporator(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporator', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEvaporatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcEvaporatorType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEvent(*args, **kwargs): return ifcopenshell.create_entity('IfcEvent', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEventTime(*args, **kwargs): return ifcopenshell.create_entity('IfcEventTime', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcEventType(*args, **kwargs): return ifcopenshell.create_entity('IfcEventType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcExtendedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcExtendedProperties', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcExternalInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalInformation', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcExternalReference(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReference', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcExternalReferenceRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalReferenceRelationship', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcExternalSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcExternalSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcExternalSpatialStructureElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcExternallyDefinedHatchStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedHatchStyle', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcExternallyDefinedSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedSurfaceStyle', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcExternallyDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcExternallyDefinedTextFont', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcExtrudedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolid', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcExtrudedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcExtrudedAreaSolidTapered', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFace(*args, **kwargs): return ifcopenshell.create_entity('IfcFace', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFaceBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBasedSurfaceModel', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFaceBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceBound', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFaceOuterBound(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceOuterBound', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFaceSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcFaceSurface', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFacetedBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrep', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFacetedBrepWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcFacetedBrepWithVoids', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFacility(*args, **kwargs): return ifcopenshell.create_entity('IfcFacility', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFacilityPart(*args, **kwargs): return ifcopenshell.create_entity('IfcFacilityPart', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFacilityPartCommon(*args, **kwargs): return ifcopenshell.create_entity('IfcFacilityPartCommon', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFailureConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcFailureConnectionCondition', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFan(*args, **kwargs): return ifcopenshell.create_entity('IfcFan', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFanType(*args, **kwargs): return ifcopenshell.create_entity('IfcFanType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcFastener', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFastenerType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFeatureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFeatureElementAddition(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementAddition', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFeatureElementSubtraction(*args, **kwargs): return ifcopenshell.create_entity('IfcFeatureElementSubtraction', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFillAreaStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyle', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFillAreaStyleHatching(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleHatching', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFillAreaStyleTiles(*args, **kwargs): return ifcopenshell.create_entity('IfcFillAreaStyleTiles', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFilter(*args, **kwargs): return ifcopenshell.create_entity('IfcFilter', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFilterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFilterType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFireSuppressionTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminal', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFireSuppressionTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFireSuppressionTerminalType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFixedReferenceSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcFixedReferenceSweptAreaSolid', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowController(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowController', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowControllerType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowControllerType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFitting', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowFittingType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowInstrument(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrument', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowInstrumentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowInstrumentType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowMeter(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeter', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowMeterType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMeterType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowMovingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDevice', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowMovingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowMovingDeviceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowSegmentType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowStorageDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDevice', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowStorageDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowStorageDeviceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminal', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTerminalType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowTreatmentDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDevice', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFlowTreatmentDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcFlowTreatmentDeviceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFooting(*args, **kwargs): return ifcopenshell.create_entity('IfcFooting', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFootingType(*args, **kwargs): return ifcopenshell.create_entity('IfcFootingType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFurnishingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFurnishingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnishingElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFurniture(*args, **kwargs): return ifcopenshell.create_entity('IfcFurniture', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcFurnitureType(*args, **kwargs): return ifcopenshell.create_entity('IfcFurnitureType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGeographicElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGeographicElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcGeographicElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGeometricCurveSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricCurveSet', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGeometricRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationContext', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGeometricRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationItem', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGeometricRepresentationSubContext(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricRepresentationSubContext', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGeometricSet(*args, **kwargs): return ifcopenshell.create_entity('IfcGeometricSet', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGeomodel(*args, **kwargs): return ifcopenshell.create_entity('IfcGeomodel', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGeoslice(*args, **kwargs): return ifcopenshell.create_entity('IfcGeoslice', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGeotechnicalAssembly(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalAssembly', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGeotechnicalElement(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGeotechnicalStratum(*args, **kwargs): return ifcopenshell.create_entity('IfcGeotechnicalStratum', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGradientCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcGradientCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGrid(*args, **kwargs): return ifcopenshell.create_entity('IfcGrid', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGridAxis(*args, **kwargs): return ifcopenshell.create_entity('IfcGridAxis', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGridPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcGridPlacement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcGroup', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcHalfSpaceSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcHalfSpaceSolid', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcHeatExchanger(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchanger', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcHeatExchangerType(*args, **kwargs): return ifcopenshell.create_entity('IfcHeatExchangerType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcHumidifier(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifier', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcHumidifierType(*args, **kwargs): return ifcopenshell.create_entity('IfcHumidifierType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcIShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcIShapeProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcImageTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcImageTexture', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcImpactProtectionDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcImpactProtectionDevice', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcImpactProtectionDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcImpactProtectionDeviceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcIndexedColourMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedColourMap', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcIndexedPolyCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolyCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcIndexedPolygonalFace(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFace', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcIndexedPolygonalFaceWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalFaceWithVoids', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcIndexedPolygonalTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedPolygonalTextureMap', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcIndexedTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTextureMap', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcIndexedTriangleTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcIndexedTriangleTextureMap', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcInterceptor(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptor', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcInterceptorType(*args, **kwargs): return ifcopenshell.create_entity('IfcInterceptorType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcIntersectionCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcIntersectionCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcInventory(*args, **kwargs): return ifcopenshell.create_entity('IfcInventory', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcIrregularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeries', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcIrregularTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcIrregularTimeSeriesValue', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcJunctionBox(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBox', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcJunctionBoxType(*args, **kwargs): return ifcopenshell.create_entity('IfcJunctionBoxType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcKerb(*args, **kwargs): return ifcopenshell.create_entity('IfcKerb', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcKerbType(*args, **kwargs): return ifcopenshell.create_entity('IfcKerbType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcLShapeProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLaborResource(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResource', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLaborResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcLaborResourceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLagTime(*args, **kwargs): return ifcopenshell.create_entity('IfcLagTime', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLamp(*args, **kwargs): return ifcopenshell.create_entity('IfcLamp', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLampType(*args, **kwargs): return ifcopenshell.create_entity('IfcLampType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLibraryInformation(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryInformation', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLibraryReference(*args, **kwargs): return ifcopenshell.create_entity('IfcLibraryReference', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLightDistributionData(*args, **kwargs): return ifcopenshell.create_entity('IfcLightDistributionData', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLightFixture(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixture', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLightFixtureType(*args, **kwargs): return ifcopenshell.create_entity('IfcLightFixtureType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLightIntensityDistribution(*args, **kwargs): return ifcopenshell.create_entity('IfcLightIntensityDistribution', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLightSource(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSource', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLightSourceAmbient(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceAmbient', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLightSourceDirectional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceDirectional', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLightSourceGoniometric(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceGoniometric', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLightSourcePositional(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourcePositional', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLightSourceSpot(*args, **kwargs): return ifcopenshell.create_entity('IfcLightSourceSpot', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLine(*args, **kwargs): return ifcopenshell.create_entity('IfcLine', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLinearElement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLinearPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPlacement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLinearPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcLinearPositioningElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLiquidTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcLiquidTerminal', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLiquidTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcLiquidTerminalType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLocalPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcLocalPlacement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcLoop', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcManifoldSolidBrep(*args, **kwargs): return ifcopenshell.create_entity('IfcManifoldSolidBrep', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMapConversion(*args, **kwargs): return ifcopenshell.create_entity('IfcMapConversion', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMappedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcMappedItem', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMarineFacility(*args, **kwargs): return ifcopenshell.create_entity('IfcMarineFacility', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMarinePart(*args, **kwargs): return ifcopenshell.create_entity('IfcMarinePart', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterial', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialClassificationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialClassificationRelationship', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialConstituent(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituent', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialConstituentSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialConstituentSet', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinition', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialDefinitionRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialDefinitionRepresentation', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialLayer(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayer', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialLayerSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSet', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialLayerSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerSetUsage', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialLayerWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialLayerWithOffsets', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialList(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialList', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialProfile(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfile', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialProfileSet(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSet', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialProfileSetUsage(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsage', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialProfileSetUsageTapering(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileSetUsageTapering', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialProfileWithOffsets(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProfileWithOffsets', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialProperties', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialRelationship', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMaterialUsageDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcMaterialUsageDefinition', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMeasureWithUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMeasureWithUnit', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMechanicalFastener(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastener', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMechanicalFastenerType(*args, **kwargs): return ifcopenshell.create_entity('IfcMechanicalFastenerType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMedicalDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDevice', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMedicalDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMedicalDeviceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMember(*args, **kwargs): return ifcopenshell.create_entity('IfcMember', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMemberType(*args, **kwargs): return ifcopenshell.create_entity('IfcMemberType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMetric(*args, **kwargs): return ifcopenshell.create_entity('IfcMetric', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMirroredProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcMirroredProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMobileTelecommunicationsAppliance(*args, **kwargs): return ifcopenshell.create_entity('IfcMobileTelecommunicationsAppliance', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMobileTelecommunicationsApplianceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMobileTelecommunicationsApplianceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMonetaryUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcMonetaryUnit', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMooringDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcMooringDevice', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMooringDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcMooringDeviceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMotorConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnection', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcMotorConnectionType(*args, **kwargs): return ifcopenshell.create_entity('IfcMotorConnectionType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcNamedUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcNamedUnit', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcNavigationElement(*args, **kwargs): return ifcopenshell.create_entity('IfcNavigationElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcNavigationElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcNavigationElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcObject(*args, **kwargs): return ifcopenshell.create_entity('IfcObject', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcObjectDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectDefinition', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcObjectPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcObjectPlacement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcObjective(*args, **kwargs): return ifcopenshell.create_entity('IfcObjective', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcOccupant(*args, **kwargs): return ifcopenshell.create_entity('IfcOccupant', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcOffsetCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcOffsetCurve2D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve2D', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcOffsetCurve3D(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurve3D', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcOffsetCurveByDistances(*args, **kwargs): return ifcopenshell.create_entity('IfcOffsetCurveByDistances', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcOpenCrossProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenCrossProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcOpenShell(*args, **kwargs): return ifcopenshell.create_entity('IfcOpenShell', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcOpeningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcOpeningElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganization', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcOrganizationRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcOrganizationRelationship', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcOrientedEdge(*args, **kwargs): return ifcopenshell.create_entity('IfcOrientedEdge', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcOuterBoundaryCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcOuterBoundaryCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcOutlet(*args, **kwargs): return ifcopenshell.create_entity('IfcOutlet', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcOutletType(*args, **kwargs): return ifcopenshell.create_entity('IfcOutletType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcOwnerHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcOwnerHistory', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcParameterizedProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcParameterizedProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPath(*args, **kwargs): return ifcopenshell.create_entity('IfcPath', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPavement(*args, **kwargs): return ifcopenshell.create_entity('IfcPavement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPavementType(*args, **kwargs): return ifcopenshell.create_entity('IfcPavementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPcurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPcurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPerformanceHistory(*args, **kwargs): return ifcopenshell.create_entity('IfcPerformanceHistory', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPermeableCoveringProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPermeableCoveringProperties', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPermit(*args, **kwargs): return ifcopenshell.create_entity('IfcPermit', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPerson(*args, **kwargs): return ifcopenshell.create_entity('IfcPerson', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPersonAndOrganization(*args, **kwargs): return ifcopenshell.create_entity('IfcPersonAndOrganization', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPhysicalComplexQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalComplexQuantity', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPhysicalQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalQuantity', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPhysicalSimpleQuantity(*args, **kwargs): return ifcopenshell.create_entity('IfcPhysicalSimpleQuantity', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPile(*args, **kwargs): return ifcopenshell.create_entity('IfcPile', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPileType(*args, **kwargs): return ifcopenshell.create_entity('IfcPileType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPipeFitting(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFitting', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPipeFittingType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeFittingType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPipeSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPipeSegmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcPipeSegmentType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPixelTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcPixelTexture', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPlacement(*args, **kwargs): return ifcopenshell.create_entity('IfcPlacement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPlanarBox(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarBox', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPlanarExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcPlanarExtent', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPlane(*args, **kwargs): return ifcopenshell.create_entity('IfcPlane', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPlate(*args, **kwargs): return ifcopenshell.create_entity('IfcPlate', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPlateType(*args, **kwargs): return ifcopenshell.create_entity('IfcPlateType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcPoint', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPointByDistanceExpression(*args, **kwargs): return ifcopenshell.create_entity('IfcPointByDistanceExpression', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPointOnCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPointOnSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcPointOnSurface', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPolyLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyLoop', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPolygonalBoundedHalfSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalBoundedHalfSpace', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPolygonalFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcPolygonalFaceSet', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPolyline(*args, **kwargs): return ifcopenshell.create_entity('IfcPolyline', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPolynomialCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcPolynomialCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPort(*args, **kwargs): return ifcopenshell.create_entity('IfcPort', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPositioningElement(*args, **kwargs): return ifcopenshell.create_entity('IfcPositioningElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPostalAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcPostalAddress', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPreDefinedColour(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedColour', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPreDefinedCurveFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedCurveFont', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPreDefinedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedItem', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPreDefinedProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedProperties', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPreDefinedPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedPropertySet', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPreDefinedTextFont(*args, **kwargs): return ifcopenshell.create_entity('IfcPreDefinedTextFont', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationItem', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPresentationLayerAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerAssignment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPresentationLayerWithStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationLayerWithStyle', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPresentationStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcPresentationStyle', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProcedure(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedure', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProcedureType(*args, **kwargs): return ifcopenshell.create_entity('IfcProcedureType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcProcess', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcProduct', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProductDefinitionShape(*args, **kwargs): return ifcopenshell.create_entity('IfcProductDefinitionShape', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProductRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcProductRepresentation', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProfileProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcProfileProperties', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProject(*args, **kwargs): return ifcopenshell.create_entity('IfcProject', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProjectLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectLibrary', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProjectOrder(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectOrder', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProjectedCRS(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectedCRS', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProjectionElement(*args, **kwargs): return ifcopenshell.create_entity('IfcProjectionElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcProperty', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPropertyAbstraction(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyAbstraction', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPropertyBoundedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyBoundedValue', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPropertyDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDefinition', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPropertyDependencyRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyDependencyRelationship', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPropertyEnumeratedValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeratedValue', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPropertyEnumeration(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyEnumeration', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPropertyListValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyListValue', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPropertyReferenceValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyReferenceValue', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPropertySet(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySet', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPropertySetDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetDefinition', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPropertySetTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySetTemplate', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPropertySingleValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertySingleValue', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPropertyTableValue(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTableValue', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplate', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPropertyTemplateDefinition(*args, **kwargs): return ifcopenshell.create_entity('IfcPropertyTemplateDefinition', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProtectiveDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDevice', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnit', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProtectiveDeviceTrippingUnitType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceTrippingUnitType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcProtectiveDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcProtectiveDeviceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPump(*args, **kwargs): return ifcopenshell.create_entity('IfcPump', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcPumpType(*args, **kwargs): return ifcopenshell.create_entity('IfcPumpType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcQuantityArea(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityArea', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcQuantityCount(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityCount', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcQuantityLength(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityLength', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcQuantityNumber(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityNumber', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcQuantitySet(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantitySet', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcQuantityTime(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityTime', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcQuantityVolume(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityVolume', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcQuantityWeight(*args, **kwargs): return ifcopenshell.create_entity('IfcQuantityWeight', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRail(*args, **kwargs): return ifcopenshell.create_entity('IfcRail', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRailType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRailing(*args, **kwargs): return ifcopenshell.create_entity('IfcRailing', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRailingType(*args, **kwargs): return ifcopenshell.create_entity('IfcRailingType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRailway(*args, **kwargs): return ifcopenshell.create_entity('IfcRailway', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRailwayPart(*args, **kwargs): return ifcopenshell.create_entity('IfcRailwayPart', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRamp(*args, **kwargs): return ifcopenshell.create_entity('IfcRamp', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRampFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlight', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRampFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampFlightType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRampType(*args, **kwargs): return ifcopenshell.create_entity('IfcRampType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRationalBSplineCurveWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineCurveWithKnots', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRationalBSplineSurfaceWithKnots(*args, **kwargs): return ifcopenshell.create_entity('IfcRationalBSplineSurfaceWithKnots', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRectangleHollowProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleHollowProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangleProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRectangularPyramid(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularPyramid', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRectangularTrimmedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcRectangularTrimmedSurface', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRecurrencePattern(*args, **kwargs): return ifcopenshell.create_entity('IfcRecurrencePattern', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcReference(*args, **kwargs): return ifcopenshell.create_entity('IfcReference', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcReferent(*args, **kwargs): return ifcopenshell.create_entity('IfcReferent', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRegularTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcRegularTimeSeries', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcReinforcedSoil(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcedSoil', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcReinforcementBarProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementBarProperties', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcReinforcementDefinitionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcementDefinitionProperties', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcReinforcingBar(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBar', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcReinforcingBarType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingBarType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcReinforcingElement(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcReinforcingElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcReinforcingMesh(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMesh', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcReinforcingMeshType(*args, **kwargs): return ifcopenshell.create_entity('IfcReinforcingMeshType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAdheresToElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAdheresToElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAggregates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAggregates', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssigns(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssigns', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssignsToActor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToActor', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssignsToControl(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToControl', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssignsToGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroup', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssignsToGroupByFactor(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToGroupByFactor', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssignsToProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProcess', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssignsToProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToProduct', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssignsToResource(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssignsToResource', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssociates(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociates', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssociatesApproval(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesApproval', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssociatesClassification(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesClassification', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssociatesConstraint(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesConstraint', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssociatesDocument(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesDocument', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssociatesLibrary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesLibrary', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssociatesMaterial(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesMaterial', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelAssociatesProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRelAssociatesProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelConnects(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnects', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelConnectsElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsElements', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelConnectsPathElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPathElements', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelConnectsPortToElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPortToElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelConnectsPorts(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsPorts', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelConnectsStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralActivity', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelConnectsStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsStructuralMember', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelConnectsWithEccentricity(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithEccentricity', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelConnectsWithRealizingElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelConnectsWithRealizingElements', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelContainedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelContainedInSpatialStructure', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelCoversBldgElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversBldgElements', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelCoversSpaces(*args, **kwargs): return ifcopenshell.create_entity('IfcRelCoversSpaces', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelDeclares(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDeclares', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelDecomposes(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDecomposes', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelDefines(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefines', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelDefinesByObject(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByObject', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelDefinesByProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByProperties', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelDefinesByTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByTemplate', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelDefinesByType(*args, **kwargs): return ifcopenshell.create_entity('IfcRelDefinesByType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelFillsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFillsElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelFlowControlElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelFlowControlElements', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelInterferesElements(*args, **kwargs): return ifcopenshell.create_entity('IfcRelInterferesElements', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelNests(*args, **kwargs): return ifcopenshell.create_entity('IfcRelNests', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelPositions(*args, **kwargs): return ifcopenshell.create_entity('IfcRelPositions', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelProjectsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelProjectsElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelReferencedInSpatialStructure(*args, **kwargs): return ifcopenshell.create_entity('IfcRelReferencedInSpatialStructure', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelSequence(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSequence', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelServicesBuildings(*args, **kwargs): return ifcopenshell.create_entity('IfcRelServicesBuildings', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelSpaceBoundary(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelSpaceBoundary1stLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary1stLevel', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelSpaceBoundary2ndLevel(*args, **kwargs): return ifcopenshell.create_entity('IfcRelSpaceBoundary2ndLevel', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelVoidsElement(*args, **kwargs): return ifcopenshell.create_entity('IfcRelVoidsElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcRelationship', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcReparametrisedCompositeCurveSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcReparametrisedCompositeCurveSegment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentation', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRepresentationContext(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationContext', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationItem', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRepresentationMap(*args, **kwargs): return ifcopenshell.create_entity('IfcRepresentationMap', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcResource(*args, **kwargs): return ifcopenshell.create_entity('IfcResource', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcResourceApprovalRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceApprovalRelationship', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcResourceConstraintRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceConstraintRelationship', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcResourceLevelRelationship(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceLevelRelationship', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcResourceTime(*args, **kwargs): return ifcopenshell.create_entity('IfcResourceTime', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRevolvedAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolid', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRevolvedAreaSolidTapered(*args, **kwargs): return ifcopenshell.create_entity('IfcRevolvedAreaSolidTapered', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRightCircularCone(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCone', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRightCircularCylinder(*args, **kwargs): return ifcopenshell.create_entity('IfcRightCircularCylinder', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRoad(*args, **kwargs): return ifcopenshell.create_entity('IfcRoad', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRoadPart(*args, **kwargs): return ifcopenshell.create_entity('IfcRoadPart', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRoof(*args, **kwargs): return ifcopenshell.create_entity('IfcRoof', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRoofType(*args, **kwargs): return ifcopenshell.create_entity('IfcRoofType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRoot(*args, **kwargs): return ifcopenshell.create_entity('IfcRoot', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcRoundedRectangleProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcRoundedRectangleProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSIUnit(*args, **kwargs): return ifcopenshell.create_entity('IfcSIUnit', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSanitaryTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminal', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSanitaryTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSanitaryTerminalType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSchedulingTime(*args, **kwargs): return ifcopenshell.create_entity('IfcSchedulingTime', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSeamCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSeamCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSecondOrderPolynomialSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSecondOrderPolynomialSpiral', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSectionProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionProperties', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSectionReinforcementProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionReinforcementProperties', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSectionedSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolid', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSectionedSolidHorizontal(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSolidHorizontal', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSectionedSpine(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSpine', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSectionedSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSectionedSurface', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSegment(*args, **kwargs): return ifcopenshell.create_entity('IfcSegment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSegmentedReferenceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSegmentedReferenceCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSensor(*args, **kwargs): return ifcopenshell.create_entity('IfcSensor', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSensorType(*args, **kwargs): return ifcopenshell.create_entity('IfcSensorType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSeventhOrderPolynomialSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSeventhOrderPolynomialSpiral', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcShadingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDevice', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcShadingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcShadingDeviceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcShapeAspect(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeAspect', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcShapeModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeModel', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcShapeRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcShapeRepresentation', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcShellBasedSurfaceModel(*args, **kwargs): return ifcopenshell.create_entity('IfcShellBasedSurfaceModel', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSign(*args, **kwargs): return ifcopenshell.create_entity('IfcSign', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSignType(*args, **kwargs): return ifcopenshell.create_entity('IfcSignType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSignal(*args, **kwargs): return ifcopenshell.create_entity('IfcSignal', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSignalType(*args, **kwargs): return ifcopenshell.create_entity('IfcSignalType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSimpleProperty(*args, **kwargs): return ifcopenshell.create_entity('IfcSimpleProperty', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSimplePropertyTemplate(*args, **kwargs): return ifcopenshell.create_entity('IfcSimplePropertyTemplate', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSineSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSineSpiral', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSite(*args, **kwargs): return ifcopenshell.create_entity('IfcSite', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSlab(*args, **kwargs): return ifcopenshell.create_entity('IfcSlab', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSlabType(*args, **kwargs): return ifcopenshell.create_entity('IfcSlabType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSlippageConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcSlippageConnectionCondition', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSolarDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDevice', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSolarDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSolarDeviceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSolidModel(*args, **kwargs): return ifcopenshell.create_entity('IfcSolidModel', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSpace(*args, **kwargs): return ifcopenshell.create_entity('IfcSpace', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSpaceHeater(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeater', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSpaceHeaterType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceHeaterType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSpaceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpaceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSpatialElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSpatialElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSpatialStructureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSpatialStructureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialStructureElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSpatialZone(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZone', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSpatialZoneType(*args, **kwargs): return ifcopenshell.create_entity('IfcSpatialZoneType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSphere(*args, **kwargs): return ifcopenshell.create_entity('IfcSphere', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSphericalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSphericalSurface', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcSpiral', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStackTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminal', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStackTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcStackTerminalType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStair(*args, **kwargs): return ifcopenshell.create_entity('IfcStair', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStairFlight(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlight', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStairFlightType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairFlightType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStairType(*args, **kwargs): return ifcopenshell.create_entity('IfcStairType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAction', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralActivity(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralActivity', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralAnalysisModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralAnalysisModel', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnection', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralConnectionCondition(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralConnectionCondition', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralCurveAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveAction', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralCurveConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveConnection', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralCurveMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMember', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralCurveMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveMemberVarying', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralCurveReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralCurveReaction', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralItem', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralLinearAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLinearAction', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralLoad(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoad', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralLoadCase(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadCase', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralLoadConfiguration(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadConfiguration', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralLoadGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadGroup', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralLoadLinearForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadLinearForce', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralLoadOrResult(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadOrResult', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralLoadPlanarForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadPlanarForce', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacement(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralLoadSingleDisplacementDistortion(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleDisplacementDistortion', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralLoadSingleForce(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForce', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralLoadSingleForceWarping(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadSingleForceWarping', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralLoadStatic(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadStatic', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralLoadTemperature(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralLoadTemperature', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralMember', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralPlanarAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPlanarAction', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralPointAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointAction', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralPointConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointConnection', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralPointReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralPointReaction', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralReaction', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralResultGroup(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralResultGroup', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralSurfaceAction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceAction', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralSurfaceConnection(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceConnection', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralSurfaceMember(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMember', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralSurfaceMemberVarying(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceMemberVarying', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStructuralSurfaceReaction(*args, **kwargs): return ifcopenshell.create_entity('IfcStructuralSurfaceReaction', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStyleModel(*args, **kwargs): return ifcopenshell.create_entity('IfcStyleModel', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStyledItem(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledItem', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcStyledRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcStyledRepresentation', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSubContractResource(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResource', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSubContractResourceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSubContractResourceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSubedge(*args, **kwargs): return ifcopenshell.create_entity('IfcSubedge', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSurface', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSurfaceCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSurfaceCurveSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceCurveSweptAreaSolid', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSurfaceFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceFeature', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSurfaceOfLinearExtrusion(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfLinearExtrusion', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSurfaceOfRevolution(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceOfRevolution', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSurfaceReinforcementArea(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceReinforcementArea', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSurfaceStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyle', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSurfaceStyleLighting(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleLighting', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSurfaceStyleRefraction(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRefraction', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSurfaceStyleRendering(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleRendering', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSurfaceStyleShading(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleShading', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSurfaceStyleWithTextures(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceStyleWithTextures', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSurfaceTexture(*args, **kwargs): return ifcopenshell.create_entity('IfcSurfaceTexture', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSweptAreaSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptAreaSolid', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSweptDiskSolid(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolid', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSweptDiskSolidPolygonal(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptDiskSolidPolygonal', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSweptSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcSweptSurface', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSwitchingDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDevice', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSwitchingDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcSwitchingDeviceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSystem(*args, **kwargs): return ifcopenshell.create_entity('IfcSystem', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSystemFurnitureElement(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcSystemFurnitureElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcSystemFurnitureElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTShapeProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTable(*args, **kwargs): return ifcopenshell.create_entity('IfcTable', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTableColumn(*args, **kwargs): return ifcopenshell.create_entity('IfcTableColumn', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTableRow(*args, **kwargs): return ifcopenshell.create_entity('IfcTableRow', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTank(*args, **kwargs): return ifcopenshell.create_entity('IfcTank', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTankType(*args, **kwargs): return ifcopenshell.create_entity('IfcTankType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTask(*args, **kwargs): return ifcopenshell.create_entity('IfcTask', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTaskTime(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTime', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTaskTimeRecurring(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskTimeRecurring', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTaskType(*args, **kwargs): return ifcopenshell.create_entity('IfcTaskType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTelecomAddress(*args, **kwargs): return ifcopenshell.create_entity('IfcTelecomAddress', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTendon(*args, **kwargs): return ifcopenshell.create_entity('IfcTendon', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTendonAnchor(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchor', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTendonAnchorType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonAnchorType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTendonConduit(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduit', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTendonConduitType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonConduitType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTendonType(*args, **kwargs): return ifcopenshell.create_entity('IfcTendonType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTessellatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedFaceSet', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTessellatedItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTessellatedItem', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTextLiteral(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteral', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTextLiteralWithExtent(*args, **kwargs): return ifcopenshell.create_entity('IfcTextLiteralWithExtent', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTextStyle(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyle', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTextStyleFontModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleFontModel', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTextStyleForDefinedFont(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleForDefinedFont', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTextStyleTextModel(*args, **kwargs): return ifcopenshell.create_entity('IfcTextStyleTextModel', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTextureCoordinate(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinate', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTextureCoordinateGenerator(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateGenerator', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTextureCoordinateIndices(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateIndices', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTextureCoordinateIndicesWithVoids(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureCoordinateIndicesWithVoids', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTextureMap(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureMap', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTextureVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertex', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTextureVertexList(*args, **kwargs): return ifcopenshell.create_entity('IfcTextureVertexList', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcThirdOrderPolynomialSpiral(*args, **kwargs): return ifcopenshell.create_entity('IfcThirdOrderPolynomialSpiral', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTimePeriod(*args, **kwargs): return ifcopenshell.create_entity('IfcTimePeriod', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTimeSeries(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeries', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTimeSeriesValue(*args, **kwargs): return ifcopenshell.create_entity('IfcTimeSeriesValue', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTopologicalRepresentationItem(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologicalRepresentationItem', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTopologyRepresentation(*args, **kwargs): return ifcopenshell.create_entity('IfcTopologyRepresentation', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcToroidalSurface(*args, **kwargs): return ifcopenshell.create_entity('IfcToroidalSurface', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTrackElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTrackElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTrackElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTrackElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTransformer(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformer', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTransformerType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransformerType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTransportElement(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTransportElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTransportationDevice(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportationDevice', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTransportationDeviceType(*args, **kwargs): return ifcopenshell.create_entity('IfcTransportationDeviceType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTrapeziumProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcTrapeziumProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTriangulatedFaceSet(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedFaceSet', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTriangulatedIrregularNetwork(*args, **kwargs): return ifcopenshell.create_entity('IfcTriangulatedIrregularNetwork', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTrimmedCurve(*args, **kwargs): return ifcopenshell.create_entity('IfcTrimmedCurve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTubeBundle(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundle', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTubeBundleType(*args, **kwargs): return ifcopenshell.create_entity('IfcTubeBundleType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTypeObject(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeObject', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTypeProcess(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProcess', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTypeProduct(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeProduct', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcTypeResource(*args, **kwargs): return ifcopenshell.create_entity('IfcTypeResource', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcUShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcUShapeProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcUnitAssignment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitAssignment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcUnitaryControlElement(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcUnitaryControlElementType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryControlElementType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcUnitaryEquipment(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipment', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcUnitaryEquipmentType(*args, **kwargs): return ifcopenshell.create_entity('IfcUnitaryEquipmentType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcValve(*args, **kwargs): return ifcopenshell.create_entity('IfcValve', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcValveType(*args, **kwargs): return ifcopenshell.create_entity('IfcValveType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcVector(*args, **kwargs): return ifcopenshell.create_entity('IfcVector', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcVehicle(*args, **kwargs): return ifcopenshell.create_entity('IfcVehicle', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcVehicleType(*args, **kwargs): return ifcopenshell.create_entity('IfcVehicleType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcVertex(*args, **kwargs): return ifcopenshell.create_entity('IfcVertex', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcVertexLoop(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexLoop', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcVertexPoint(*args, **kwargs): return ifcopenshell.create_entity('IfcVertexPoint', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcVibrationDamper(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamper', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcVibrationDamperType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationDamperType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcVibrationIsolator(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolator', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcVibrationIsolatorType(*args, **kwargs): return ifcopenshell.create_entity('IfcVibrationIsolatorType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcVirtualElement(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualElement', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcVirtualGridIntersection(*args, **kwargs): return ifcopenshell.create_entity('IfcVirtualGridIntersection', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcVoidingFeature(*args, **kwargs): return ifcopenshell.create_entity('IfcVoidingFeature', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcWall(*args, **kwargs): return ifcopenshell.create_entity('IfcWall', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcWallStandardCase(*args, **kwargs): return ifcopenshell.create_entity('IfcWallStandardCase', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcWallType(*args, **kwargs): return ifcopenshell.create_entity('IfcWallType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcWasteTerminal(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminal', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcWasteTerminalType(*args, **kwargs): return ifcopenshell.create_entity('IfcWasteTerminalType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcWindow(*args, **kwargs): return ifcopenshell.create_entity('IfcWindow', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcWindowLiningProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowLiningProperties', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcWindowPanelProperties(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowPanelProperties', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcWindowType(*args, **kwargs): return ifcopenshell.create_entity('IfcWindowType', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcWorkCalendar(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkCalendar', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcWorkControl(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkControl', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcWorkPlan(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkPlan', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcWorkSchedule(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkSchedule', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcWorkTime(*args, **kwargs): return ifcopenshell.create_entity('IfcWorkTime', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcZShapeProfileDef(*args, **kwargs): return ifcopenshell.create_entity('IfcZShapeProfileDef', 'IFC4X3_TC1', *args, **kwargs) + + +def IfcZone(*args, **kwargs): return ifcopenshell.create_entity('IfcZone', 'IFC4X3_TC1', *args, **kwargs) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcBoxAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcBoxAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['top-left','top-middle','top-right','middle-left','center','middle-right','bottom-left','bottom-middle','bottom-right'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCardinalPointReference_GreaterThanZero: + SCOPE = "type" + TYPE_NAME = "IfcCardinalPointReference" + RULE_NAME = "GreaterThanZero" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCompoundPlaneAngleMeasure_MinutesInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MinutesInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[2 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_SecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "SecondsInRange" + + @staticmethod + def __call__(self): + + + assert (abs(self[3 - 1])) < 60 + + + + +class IfcCompoundPlaneAngleMeasure_MicrosecondsInRange: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "MicrosecondsInRange" + + @staticmethod + def __call__(self): + + + assert (sizeof(self) == 3) or ((abs(self[4 - 1])) < 1000000) + + + + +class IfcCompoundPlaneAngleMeasure_ConsistentSign: + SCOPE = "type" + TYPE_NAME = "IfcCompoundPlaneAngleMeasure" + RULE_NAME = "ConsistentSign" + + @staticmethod + def __call__(self): + + + assert (((self[1 - 1]) >= 0) and ((self[2 - 1]) >= 0) and ((self[3 - 1]) >= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) >= 0))) or (((self[1 - 1]) <= 0) and ((self[2 - 1]) <= 0) and ((self[3 - 1]) <= 0) and ((sizeof(self) == 3) or ((self[4 - 1]) <= 0))) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDayInMonthNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInMonthNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 31 + + + + + +class IfcDayInWeekNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcDayInWeekNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 7 + + + + + + + + + + + + + + + + + +class IfcDimensionCount_WR1: + SCOPE = "type" + TYPE_NAME = "IfcDimensionCount" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0 < self <= 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFontStyle_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontStyle" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','italic','oblique'] + + + + + +class IfcFontVariant_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontVariant" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps'] + + + + + +class IfcFontWeight_WR1: + SCOPE = "type" + TYPE_NAME = "IfcFontWeight" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['normal','small-caps','100','200','300','400','500','600','700','800','900'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcHeatingValueMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcHeatingValueMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMonthInYearNumber_ValidRange: + SCOPE = "type" + TYPE_NAME = "IfcMonthInYearNumber" + RULE_NAME = "ValidRange" + + @staticmethod + def __call__(self): + + + assert 1 <= self <= 12 + + + + + + + + + + + + + + +class IfcNonNegativeLengthMeasure_NotNegative: + SCOPE = "type" + TYPE_NAME = "IfcNonNegativeLengthMeasure" + RULE_NAME = "NotNegative" + + @staticmethod + def __call__(self): + + + assert self >= 0. + + + + + +class IfcNormalisedRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcNormalisedRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + +class IfcPHMeasure_WR21: + SCOPE = "type" + TYPE_NAME = "IfcPHMeasure" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 14.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPositiveInteger_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveInteger" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0 + + + + + +class IfcPositiveLengthMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveLengthMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositivePlaneAngleMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositivePlaneAngleMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + +class IfcPositiveRatioMeasure_WR1: + SCOPE = "type" + TYPE_NAME = "IfcPositiveRatioMeasure" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self > 0. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcSpecularRoughness_WR1: + SCOPE = "type" + TYPE_NAME = "IfcSpecularRoughness" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 0.0 <= self <= 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTextAlignment_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextAlignment" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['left','right','center','justify'] + + + + + +class IfcTextDecoration_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextDecoration" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['none','underline','overline','line-through','blink'] + + + + + + + + + + + + + + +class IfcTextTransformation_WR1: + SCOPE = "type" + TYPE_NAME = "IfcTextTransformation" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self in ['capitalize','uppercase','lowercase','none'] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcActorRole_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcActorRole" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + role = self.Role + + assert (role != IfcRoleEnum.USERDEFINED) or ((role == IfcRoleEnum.USERDEFINED) and exists(self.UserDefinedRole)) + + + + + +class IfcActuator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcActuator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcActuator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcactuatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcActuatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcActuatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcActuatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcActuatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + purpose = self.Purpose + + assert (not exists(purpose)) or ((purpose != IfcAddressTypeEnum.USERDEFINED) or ((purpose == IfcAddressTypeEnum.USERDEFINED) and exists(self.UserDefinedPurpose))) + + + + + +class IfcAdvancedBrep_HasAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrep" + RULE_NAME = "HasAdvancedFaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([afs for afs in self.Outer.CfsFaces if not 'ifc4x3_tc1.ifcadvancedface' in typeof(afs)])) == 0 + + + + + +class IfcAdvancedBrepWithVoids_VoidsHaveAdvancedFaces: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedBrepWithVoids" + RULE_NAME = "VoidsHaveAdvancedFaces" + + @staticmethod + def __call__(self): + voids = self.Voids + + assert (sizeof([vsh for vsh in voids if (sizeof([afs for afs in vsh.CfsFaces if not 'ifc4x3_tc1.ifcadvancedface' in typeof(afs)])) == 0])) == 0 + + + + + +class IfcAdvancedFace_ApplicableEdgeCurves: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableEdgeCurves" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x3_tc1.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not (sizeof(['ifc4x3_tc1.ifcline','ifc4x3_tc1.ifcconic','ifc4x3_tc1.ifcpolyline','ifc4x3_tc1.ifcbsplinecurve'] * typeof(oe.EdgeElement.EdgeGeometry))) == 1])) == 0])) == 0 + + + + +class IfcAdvancedFace_ApplicableSurface: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "ApplicableSurface" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_tc1.ifcelementarysurface','ifc4x3_tc1.ifcsweptsurface','ifc4x3_tc1.ifcbsplinesurface'] * typeof(self.FaceSurface))) == 1 + + + + +class IfcAdvancedFace_RequiresEdgeCurve: + SCOPE = "entity" + TYPE_NAME = "IfcAdvancedFace" + RULE_NAME = "RequiresEdgeCurve" + + @staticmethod + def __call__(self): + + + assert (sizeof([elpfbnds for elpfbnds in [bnds for bnds in self.Bounds if 'ifc4x3_tc1.ifcedgeloop' in typeof(bnds.Bound)] if not (sizeof([oe for oe in elpfbnds.Bound.EdgeList if not 'ifc4x3_tc1.ifcedgecurve' in typeof(oe.EdgeElement)])) == 0])) == 0 + + + + + +class IfcAirTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcairterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirTerminalBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcairterminalboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirTerminalBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAirToAirHeatRecovery_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAirToAirHeatRecovery_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecovery" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcairtoairheatrecoverytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAirToAirHeatRecoveryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAirToAirHeatRecoveryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) or ((predefinedtype == IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAlarm_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAlarm_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAlarm" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcalarmtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAlarmType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAlarmType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAlarmTypeEnum.USERDEFINED) or ((predefinedtype == IfcAlarmTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcApproval_HasIdentifierOrName: + SCOPE = "entity" + TYPE_NAME = "IfcApproval" + RULE_NAME = "HasIdentifierOrName" + + @staticmethod + def __call__(self): + identifier = self.Identifier + name = self.Name + + assert exists(identifier) or exists(name) + + + + + + + + +class IfcArbitraryClosedProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert outercurve.Dim == 2 + + + + +class IfcArbitraryClosedProfileDef_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x3_tc1.ifcline' in typeof(outercurve) + + + + +class IfcArbitraryClosedProfileDef_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryClosedProfileDef" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + outercurve = self.OuterCurve + + assert not 'ifc4x3_tc1.ifcoffsetcurve2d' in typeof(outercurve) + + + + + +class IfcArbitraryOpenProfileDef_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_tc1.ifccenterlineprofiledef' in typeof(self)) or (self.ProfileType == IfcProfileTypeEnum.CURVE) + + + + +class IfcArbitraryOpenProfileDef_WR12: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryOpenProfileDef" + RULE_NAME = "WR12" + + @staticmethod + def __call__(self): + curve = self.Curve + + assert curve.Dim == 2 + + + + + +class IfcArbitraryProfileDefWithVoids_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == area + + + + +class IfcArbitraryProfileDefWithVoids_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if temp.Dim != 2])) == 0 + + + + +class IfcArbitraryProfileDefWithVoids_WR3: + SCOPE = "entity" + TYPE_NAME = "IfcArbitraryProfileDefWithVoids" + RULE_NAME = "WR3" + + @staticmethod + def __call__(self): + innercurves = self.InnerCurves + + assert (sizeof([temp for temp in innercurves if 'ifc4x3_tc1.ifcline' in typeof(temp)])) == 0 + + + + + + + + +class IfcAsymmetricIShapeProfileDef_ValidBottomFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidBottomFilletRadius" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + bottomflangefilletradius = self.BottomFlangeFilletRadius + + assert (not exists(bottomflangefilletradius)) or (bottomflangefilletradius <= ((bottomflangewidth - webthickness) / 2.)) + + + + +class IfcAsymmetricIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + bottomflangethickness = self.BottomFlangeThickness + topflangethickness = self.TopFlangeThickness + + assert (not exists(topflangethickness)) or ((bottomflangethickness + topflangethickness) < overalldepth) + + + + +class IfcAsymmetricIShapeProfileDef_ValidTopFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidTopFilletRadius" + + @staticmethod + def __call__(self): + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + topflangefilletradius = self.TopFlangeFilletRadius + + assert (not exists(topflangefilletradius)) or (topflangefilletradius <= ((topflangewidth - webthickness) / 2.)) + + + + +class IfcAsymmetricIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcAsymmetricIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + bottomflangewidth = self.BottomFlangeWidth + webthickness = self.WebThickness + topflangewidth = self.TopFlangeWidth + + assert (webthickness < bottomflangewidth) and (webthickness < topflangewidth) + + + + + +class IfcAudioVisualAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcAudioVisualAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcaudiovisualappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcAudioVisualApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcAudioVisualApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAudioVisualApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcAudioVisualApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcAxis1Placement_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis1Placement_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis1Placement_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis1Placement" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_tc1.ifccartesianpoint' in typeof(self.Location) + + + + +def calc_IfcAxis1Placement_Z(self): + axis = self.Axis + return \ + nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + + + + +class IfcAxis2Placement2D_LocationIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIs2D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 2 + + + + +class IfcAxis2Placement2D_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_tc1.ifccartesianpoint' in typeof(self.Location) + + + + +class IfcAxis2Placement2D_RefDirIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement2D" + RULE_NAME = "RefDirIs2D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 2) + + + + +def calc_IfcAxis2Placement2D_P(self): + refdirection = self.RefDirection + return \ + IfcBuild2Axes(refdirection) + + + + +class IfcAxis2Placement3D_AxisAndRefDirProvision: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisAndRefDirProvision" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert not exists(axis) ^ exists(refdirection) + + + + +class IfcAxis2Placement3D_AxisIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisIs3D" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (not exists(axis)) or (axis.Dim == 3) + + + + +class IfcAxis2Placement3D_AxisToRefDirPosition: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "AxisToRefDirPosition" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + +class IfcAxis2Placement3D_LocationIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIs3D" + + @staticmethod + def __call__(self): + + + assert self.Location.Dim == 3 + + + + +class IfcAxis2Placement3D_LocationIsCP: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "LocationIsCP" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_tc1.ifccartesianpoint' in typeof(self.Location) + + + + +class IfcAxis2Placement3D_RefDirIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2Placement3D" + RULE_NAME = "RefDirIs3D" + + @staticmethod + def __call__(self): + refdirection = self.RefDirection + + assert (not exists(refdirection)) or (refdirection.Dim == 3) + + + + +def calc_IfcAxis2Placement3D_P(self): + axis = self.Axis + refdirection = self.RefDirection + return \ + IfcBuildAxes(axis,refdirection) + + + + +class IfcAxis2PlacementLinear_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2PlacementLinear" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_tc1.ifcpointbydistanceexpression' in typeof(self.Location) + + + + +class IfcAxis2PlacementLinear_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcAxis2PlacementLinear" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + axis = self.Axis + refdirection = self.RefDirection + + assert (not exists(axis)) or (not exists(refdirection)) or (IfcCrossProduct(axis,refdirection).Magnitude > 0.0) + + + + + +class IfcBSplineCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + controlpointslist = self.ControlPointsList + + assert (sizeof([temp for temp in controlpointslist if temp.Dim != (controlpointslist[1 - 1].Dim)])) == 0 + + + + +def calc_IfcBSplineCurve_UpperIndexOnControlPoints(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineCurve_ControlPoints(self): + controlpointslist = self.ControlPointsList + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + return \ + IfcListToArray(controlpointslist,0,upperindexoncontrolpoints) + + + + +class IfcBSplineCurveWithKnots_ConsistentBSpline: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "ConsistentBSpline" + + @staticmethod + def __call__(self): + degree = self.Degree + upperindexoncontrolpoints = self.UpperIndexOnControlPoints + knotmultiplicities = self.KnotMultiplicities + knots = self.Knots + upperindexonknots = self.UpperIndexOnKnots + + assert IfcConstraintsParamBSpline(degree,upperindexonknots,upperindexoncontrolpoints,knotmultiplicities,knots) + + + + +class IfcBSplineCurveWithKnots_CorrespondingKnotLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineCurveWithKnots" + RULE_NAME = "CorrespondingKnotLists" + + @staticmethod + def __call__(self): + knotmultiplicities = self.KnotMultiplicities + upperindexonknots = self.UpperIndexOnKnots + + assert sizeof(knotmultiplicities) == upperindexonknots + + + + +def calc_IfcBSplineCurveWithKnots_UpperIndexOnKnots(self): + knots = self.Knots + return \ + sizeof(knots) + + + + +def calc_IfcBSplineSurface_UUpper(self): + controlpointslist = self.ControlPointsList + return \ + sizeof(controlpointslist) - 1 + + + +def calc_IfcBSplineSurface_VUpper(self): + controlpointslist = self.ControlPointsList + return \ + (sizeof(controlpointslist[1 - 1])) - 1 + + + +def calc_IfcBSplineSurface_ControlPoints(self): + controlpointslist = self.ControlPointsList + uupper = self.UUpper + vupper = self.VUpper + return \ + IfcMakeArrayOfArray(controlpointslist,0,uupper,0,vupper) + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingULists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingULists" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + knotuupper = self.KnotUUpper + + assert sizeof(umultiplicities) == knotuupper + + + + +class IfcBSplineSurfaceWithKnots_CorrespondingVLists: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingVLists" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + knotvupper = self.KnotVUpper + + assert sizeof(vmultiplicities) == knotvupper + + + + +class IfcBSplineSurfaceWithKnots_UDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "UDirectionConstraints" + + @staticmethod + def __call__(self): + umultiplicities = self.UMultiplicities + uknots = self.UKnots + knotuupper = self.KnotUUpper + + assert IfcConstraintsParamBSpline(self.UDegree,knotuupper,self.UUpper,umultiplicities,uknots) + + + + +class IfcBSplineSurfaceWithKnots_VDirectionConstraints: + SCOPE = "entity" + TYPE_NAME = "IfcBSplineSurfaceWithKnots" + RULE_NAME = "VDirectionConstraints" + + @staticmethod + def __call__(self): + vmultiplicities = self.VMultiplicities + vknots = self.VKnots + knotvupper = self.KnotVUpper + + assert IfcConstraintsParamBSpline(self.VDegree,knotvupper,self.VUpper,vmultiplicities,vknots) + + + + +def calc_IfcBSplineSurfaceWithKnots_KnotVUpper(self): + vknots = self.VKnots + return \ + sizeof(vknots) + + + +def calc_IfcBSplineSurfaceWithKnots_KnotUUpper(self): + uknots = self.UKnots + return \ + sizeof(uknots) + + + + +class IfcBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBearing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBearing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBearing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcbearingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBearingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBearingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBearingTypeEnum.USERDEFINED) or ((predefinedtype == IfcBearingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBlobTexture_RasterCodeByteStream: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "RasterCodeByteStream" + + @staticmethod + def __call__(self): + rastercode = self.RasterCode + + assert (blength(rastercode) % 8) == 0 + + + + +class IfcBlobTexture_SupportedRasterFormat: + SCOPE = "entity" + TYPE_NAME = "IfcBlobTexture" + RULE_NAME = "SupportedRasterFormat" + + @staticmethod + def __call__(self): + + + assert self.RasterFormat in ['bmp','jpg','gif','png'] + + + + + + + + +class IfcBoiler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBoiler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBoiler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcboilertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBoilerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBoilerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBoilerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBoilerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBooleanClippingResult_FirstOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "FirstOperandType" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert ('ifc4x3_tc1.ifcsweptareasolid' in typeof(firstoperand)) or ('ifc4x3_tc1.ifcsweptdiscsolid' in typeof(firstoperand)) or ('ifc4x3_tc1.ifcbooleanclippingresult' in typeof(firstoperand)) + + + + +class IfcBooleanClippingResult_OperatorType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "OperatorType" + + @staticmethod + def __call__(self): + operator = self.Operator + + assert operator == difference + + + + +class IfcBooleanClippingResult_SecondOperandType: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanClippingResult" + RULE_NAME = "SecondOperandType" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert 'ifc4x3_tc1.ifchalfspacesolid' in typeof(secondoperand) + + + + + +class IfcBooleanResult_FirstOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "FirstOperandClosed" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + + assert (not 'ifc4x3_tc1.ifctessellatedfaceset' in typeof(firstoperand)) or (exists(firstoperand.Closed) and firstoperand.Closed) + + + + +class IfcBooleanResult_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + firstoperand = self.FirstOperand + secondoperand = self.SecondOperand + + assert firstoperand.Dim == secondoperand.Dim + + + + +class IfcBooleanResult_SecondOperandClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBooleanResult" + RULE_NAME = "SecondOperandClosed" + + @staticmethod + def __call__(self): + secondoperand = self.SecondOperand + + assert (not 'ifc4x3_tc1.ifctessellatedfaceset' in typeof(secondoperand)) or (exists(secondoperand.Closed) and secondoperand.Closed) + + + + +def calc_IfcBooleanResult_Dim(self): + firstoperand = self.FirstOperand + return \ + firstoperand.Dim + + + + + + + + + + +class IfcBoundaryCurve_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcBoundaryCurve" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + + + assert self.ClosedCurve + + + + + + + + + + + + + + + + + + + + + + + +def calc_IfcBoundingBox_Dim(self): + + return \ + 3 + + + + +class IfcBoxedHalfSpace_UnboundedSurface: + SCOPE = "entity" + TYPE_NAME = "IfcBoxedHalfSpace" + RULE_NAME = "UnboundedSurface" + + @staticmethod + def __call__(self): + + + assert not 'ifc4x3_tc1.ifccurveboundedplane' in typeof(self.BaseSurface) + + + + + +class IfcBridge_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBridge" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBridgeTypeEnum.USERDEFINED) or ((predefinedtype == IfcBridgeTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcBridgePart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBridgePart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBridgePartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBridgePartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcBuildingElementPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementPart_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPart" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcbuildingelementparttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBuildingElementPartType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementPartType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementPartTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcBuildingElementProxy_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBuildingElementProxy_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcbuildingelementproxytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + +class IfcBuildingElementProxy_HasObjectName: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxy" + RULE_NAME = "HasObjectName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcBuildingElementProxyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingElementProxyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBuildingElementProxyTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingElementProxyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcBuildingSystem_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuildingSystem" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuildingSystemTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuildingSystemTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcBuiltElement_MaxOneMaterialAssociation: + SCOPE = "entity" + TYPE_NAME = "IfcBuiltElement" + RULE_NAME = "MaxOneMaterialAssociation" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.HasAssociations if 'ifc4x3_tc1.ifcrelassociatesmaterial' in typeof(temp)])) <= 1 + + + + + + + + +class IfcBuiltSystem_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBuiltSystem" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBuiltSystemTypeEnum.USERDEFINED) or ((predefinedtype == IfcBuiltSystemTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcBurner_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcBurner_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcBurner" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcburnertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcBurnerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcBurnerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcBurnerTypeEnum.USERDEFINED) or ((predefinedtype == IfcBurnerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCShapeProfileDef_ValidGirth: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidGirth" + + @staticmethod + def __call__(self): + depth = self.Depth + girth = self.Girth + + assert girth < (depth / 2.) + + + + +class IfcCShapeProfileDef_ValidInternalFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidInternalFilletRadius" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + internalfilletradius = self.InternalFilletRadius + + assert (not exists(internalfilletradius)) or ((internalfilletradius <= ((width / 2.) - wallthickness)) and (internalfilletradius <= ((depth / 2.) - wallthickness))) + + + + +class IfcCShapeProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcCShapeProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + wallthickness = self.WallThickness + + assert (wallthickness < (width / 2.)) and (wallthickness < (depth / 2.)) + + + + + +class IfcCableCarrierFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccablecarrierfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableCarrierSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableCarrierSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccablecarriersegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableCarrierSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableCarrierSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableCarrierSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableCarrierSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccablefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCableSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCableSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccablesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCableSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCableSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCableSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcCableSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCaissonFoundation_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCaissonFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccaissonfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCaissonFoundationType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCaissonFoundationType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCaissonFoundationTypeEnum.USERDEFINED) or ((predefinedtype == IfcCaissonFoundationTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCartesianPoint_CP2Dor3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianPoint" + RULE_NAME = "CP2Dor3D" + + @staticmethod + def __call__(self): + coordinates = self.Coordinates + + assert hiindex(coordinates) >= 2 + + + + + +def calc_IfcCartesianPointList_Dim(self): + + return \ + IfcPointListDim(self) + + + + + + + + + + +class IfcCartesianTransformationOperator_ScaleGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator" + RULE_NAME = "ScaleGreaterZero" + + @staticmethod + def __call__(self): + scl = self.Scl + + assert scl > 0.0 + + + + +def calc_IfcCartesianTransformationOperator_Scl(self): + scale = self.Scale + return \ + nvl(scale,1.0) + + + +def calc_IfcCartesianTransformationOperator_Dim(self): + localorigin = self.LocalOrigin + return \ + localorigin.Dim + + + + +class IfcCartesianTransformationOperator2D_Axis1Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis1Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 2) + + + + +class IfcCartesianTransformationOperator2D_Axis2Is2D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "Axis2Is2D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 2) + + + + +class IfcCartesianTransformationOperator2D_DimEqual2: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2D" + RULE_NAME = "DimEqual2" + + @staticmethod + def __call__(self): + + + assert self.Dim == 2 + + + + +def calc_IfcCartesianTransformationOperator2D_U(self): + + return \ + IfcBaseAxis(2,self.Axis1,self.Axis2,None) + + + + +class IfcCartesianTransformationOperator2DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator2DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator2DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + + +class IfcCartesianTransformationOperator3D_Axis1Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis1Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis1)) or (self.Axis1.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis2Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis2Is3D" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Axis2)) or (self.Axis2.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_Axis3Is3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "Axis3Is3D" + + @staticmethod + def __call__(self): + axis3 = self.Axis3 + + assert (not exists(axis3)) or (axis3.Dim == 3) + + + + +class IfcCartesianTransformationOperator3D_DimIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3D" + RULE_NAME = "DimIs3D" + + @staticmethod + def __call__(self): + + + assert self.Dim == 3 + + + + +def calc_IfcCartesianTransformationOperator3D_U(self): + axis3 = self.Axis3 + return \ + IfcBaseAxis(3,self.Axis1,self.Axis2,axis3) + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale2GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale2GreaterZero" + + @staticmethod + def __call__(self): + scl2 = self.Scl2 + + assert scl2 > 0.0 + + + + +class IfcCartesianTransformationOperator3DnonUniform_Scale3GreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcCartesianTransformationOperator3DnonUniform" + RULE_NAME = "Scale3GreaterZero" + + @staticmethod + def __call__(self): + scl3 = self.Scl3 + + assert scl3 > 0.0 + + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl2(self): + scale2 = self.Scale2 + return \ + nvl(scale2,self.Scl) + + + +def calc_IfcCartesianTransformationOperator3DnonUniform_Scl3(self): + scale3 = self.Scale3 + return \ + nvl(scale3,self.Scl) + + + + + + + +class IfcChiller_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChiller_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChiller" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcchillertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChillerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChillerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChillerTypeEnum.USERDEFINED) or ((predefinedtype == IfcChillerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcChimney_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcChimney_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcChimney" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcchimneytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcChimneyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcChimneyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcChimneyTypeEnum.USERDEFINED) or ((predefinedtype == IfcChimneyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcCircleHollowProfileDef_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcCircleHollowProfileDef" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert wallthickness < self.Radius + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcCoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoil_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoil" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccoiltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoilType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoilType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoilTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcColumn_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcColumn_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcColumn" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccolumntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcColumnType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcColumnType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcColumnTypeEnum.USERDEFINED) or ((predefinedtype == IfcColumnTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcComplexProperty_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert (sizeof([temp for temp in hasproperties if self == temp])) == 0 + + + + +class IfcComplexProperty_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcComplexProperty" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + +class IfcComplexPropertyTemplate_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert (sizeof([temp for temp in haspropertytemplates if self == temp])) == 0 + + + + +class IfcComplexPropertyTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcComplexPropertyTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + + +class IfcCompositeCurve_CurveContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "CurveContinuous" + + @staticmethod + def __call__(self): + segments = self.Segments + closedcurve = self.ClosedCurve + + assert ((not closedcurve) and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 1)) or (closedcurve and ((sizeof([temp for temp in segments if temp.Transition == discontinuous])) == 0)) + + + + +class IfcCompositeCurve_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurve" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (sizeof([temp for temp in segments if temp.Dim != (segments[1 - 1].Dim)])) == 0 + + + + +def calc_IfcCompositeCurve_NSegments(self): + segments = self.Segments + return \ + sizeof(segments) + + + +def calc_IfcCompositeCurve_ClosedCurve(self): + segments = self.Segments + nsegments = self.NSegments + return \ + (segments[nsegments - 1].Transition) != discontinuous + + + + +class IfcCompositeCurveOnSurface_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveOnSurface" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + + assert sizeof(basissurface) > 0 + + + + +def calc_IfcCompositeCurveOnSurface_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + +class IfcCompositeCurveSegment_ParentIsBoundedCurve: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeCurveSegment" + RULE_NAME = "ParentIsBoundedCurve" + + @staticmethod + def __call__(self): + parentcurve = self.ParentCurve + + assert 'ifc4x3_tc1.ifcboundedcurve' in typeof(parentcurve) + + + + + +class IfcCompositeProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if temp.ProfileType != (profiles[1 - 1].ProfileType)])) == 0 + + + + +class IfcCompositeProfileDef_NoRecursion: + SCOPE = "entity" + TYPE_NAME = "IfcCompositeProfileDef" + RULE_NAME = "NoRecursion" + + @staticmethod + def __call__(self): + profiles = self.Profiles + + assert (sizeof([temp for temp in profiles if 'ifc4x3_tc1.ifccompositeprofiledef' in typeof(temp)])) == 0 + + + + + +class IfcCompressor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCompressor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCompressor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccompressortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCompressorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCompressorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCompressorTypeEnum.USERDEFINED) or ((predefinedtype == IfcCompressorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCondenser_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCondenser_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCondenser" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccondensertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCondenserType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCondenserType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCondenserTypeEnum.USERDEFINED) or ((predefinedtype == IfcCondenserTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcConstraint_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcConstraint" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + constraintgrade = self.ConstraintGrade + + assert (constraintgrade != IfcConstraintEnum.USERDEFINED) or ((constraintgrade == IfcConstraintEnum.USERDEFINED) and exists(self.UserDefinedGrade)) + + + + + +class IfcConstructionEquipmentResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionEquipmentResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionEquipmentResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionMaterialResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionMaterialResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionMaterialResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionMaterialResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionMaterialResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +class IfcConstructionProductResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcConstructionProductResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConstructionProductResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConstructionProductResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcConstructionProductResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + + + + + + + + + + + + + +class IfcController_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcController_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcController" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccontrollertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcControllerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcControllerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcControllerTypeEnum.USERDEFINED) or ((predefinedtype == IfcControllerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcConveyorSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcConveyorSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcConveyorSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcConveyorSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcconveyorsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcConveyorSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcConveyorSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcConveyorSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcConveyorSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCooledBeam_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCooledBeam_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeam" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccooledbeamtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCooledBeamType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCooledBeamType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCooledBeamTypeEnum.USERDEFINED) or ((predefinedtype == IfcCooledBeamTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCoolingTower_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCoolingTower_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTower" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccoolingtowertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoolingTowerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoolingTowerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoolingTowerTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoolingTowerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + +class IfcCourse_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCourse" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCourseTypeEnum.USERDEFINED) or ((predefinedtype == IfcCourseTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCourse_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCourse" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccoursetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCourseType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCourseType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCourseTypeEnum.USERDEFINED) or ((predefinedtype == IfcCourseTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCovering_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCovering_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCovering" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccoveringtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCoveringType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCoveringType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCoveringTypeEnum.USERDEFINED) or ((predefinedtype == IfcCoveringTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcCrewResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcCrewResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCrewResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCrewResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcCrewResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + +def calc_IfcCsgPrimitive3D_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcCurtainWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcCurtainWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifccurtainwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcCurtainWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcCurtainWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcCurtainWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcCurtainWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcCurve_Dim(self): + + return \ + IfcCurveDim(self) + + + + + + + + + + + + + +class IfcCurveStyle_IdentifiableCurveStyle: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "IdentifiableCurveStyle" + + @staticmethod + def __call__(self): + curvefont = self.CurveFont + curvewidth = self.CurveWidth + curvecolour = self.CurveColour + + assert exists(curvefont) or exists(curvewidth) or exists(curvecolour) + + + + +class IfcCurveStyle_MeasureOfWidth: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyle" + RULE_NAME = "MeasureOfWidth" + + @staticmethod + def __call__(self): + curvewidth = self.CurveWidth + + assert (not exists(curvewidth)) or ('ifc4x3_tc1.ifcpositivelengthmeasure' in typeof(curvewidth)) or (('ifc4x3_tc1.ifcdescriptivemeasure' in typeof(curvewidth)) and (curvewidth == 'bylayer')) + + + + + + + + + + + +class IfcCurveStyleFontPattern_VisibleLengthGreaterEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcCurveStyleFontPattern" + RULE_NAME = "VisibleLengthGreaterEqualZero" + + @staticmethod + def __call__(self): + visiblesegmentlength = self.VisibleSegmentLength + + assert visiblesegmentlength >= 0. + + + + + + + + +class IfcDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDeepFoundation_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDeepFoundation" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcdeepfoundationtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + + + + +class IfcDerivedProfileDef_InvariantProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedProfileDef" + RULE_NAME = "InvariantProfileType" + + @staticmethod + def __call__(self): + parentprofile = self.ParentProfile + + assert self.ProfileType == parentprofile.ProfileType + + + + + +class IfcDerivedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof(elements) > 1) or ((sizeof(elements) == 1) and ((elements[1 - 1].Exponent) != 1)) + + + + +class IfcDerivedUnit_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcDerivedUnit" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + unittype = self.UnitType + + assert (unittype != IfcDerivedUnitEnum.USERDEFINED) or ((unittype == IfcDerivedUnitEnum.USERDEFINED) and exists(self.UserDefinedType)) + + + + +def calc_IfcDerivedUnit_Dimensions(self): + elements = self.Elements + return \ + IfcDeriveDimensionalExponents(elements) + + + + + + + + + + +class IfcDirection_MagnitudeGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcDirection" + RULE_NAME = "MagnitudeGreaterZero" + + @staticmethod + def __call__(self): + directionratios = self.DirectionRatios + + assert (sizeof([tmp for tmp in directionratios if tmp != 0.0])) > 0 + + + + +def calc_IfcDirection_Dim(self): + directionratios = self.DirectionRatios + return \ + hiindex(directionratios) + + + + +class IfcDirectrixCurveSweptAreaSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcDirectrixCurveSweptAreaSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x3_tc1.ifcconic','ifc4x3_tc1.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + + + + + +class IfcDiscreteAccessory_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDiscreteAccessory_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessory" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcdiscreteaccessorytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDiscreteAccessoryType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDiscreteAccessoryType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDiscreteAccessoryTypeEnum.USERDEFINED) or ((predefinedtype == IfcDiscreteAccessoryTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDistributionChamberElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDistributionChamberElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcdistributionchamberelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDistributionChamberElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionChamberElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDistributionChamberElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcDistributionChamberElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcDistributionSystem_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDistributionSystem" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDistributionSystemEnum.USERDEFINED) or ((predefinedtype == IfcDistributionSystemEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcDocumentReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcDocumentReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + name = self.Name + referenceddocument = self.ReferencedDocument + + assert exists(name) ^ exists(referenceddocument) + + + + + +class IfcDoor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDoorTypeEnum.USERDEFINED) or ((predefinedtype == IfcDoorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDoor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDoor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcdoortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDoorLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcDoorLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + thresholddepth = self.ThresholdDepth + thresholdthickness = self.ThresholdThickness + + assert not exists(thresholddepth) and (not exists(thresholdthickness)) + + + + +class IfcDoorLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + transomthickness = self.TransomThickness + transomoffset = self.TransomOffset + + assert (exists(transomoffset) and exists(transomthickness)) ^ ((not exists(transomoffset)) and (not exists(transomthickness))) + + + + +class IfcDoorLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + casingthickness = self.CasingThickness + casingdepth = self.CasingDepth + + assert (exists(casingdepth) and exists(casingthickness)) ^ ((not exists(casingdepth)) and (not exists(casingthickness))) + + + + +class IfcDoorLiningProperties_WR35: + SCOPE = "entity" + TYPE_NAME = "IfcDoorLiningProperties" + RULE_NAME = "WR35" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and ('ifc4x3_tc1.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) + + + + + +class IfcDoorPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and ('ifc4x3_tc1.ifcdoortype' in (typeof(self.DefinesType[1 - 1]))) + + + + + +class IfcDoorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDoorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDoorTypeEnum.USERDEFINED) or ((predefinedtype == IfcDoorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDraughtingPreDefinedColour_PreDefinedColourNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedColour" + RULE_NAME = "PreDefinedColourNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['black','red','green','blue','yellow','magenta','cyan','white','bylayer'] + + + + + +class IfcDraughtingPreDefinedCurveFont_PreDefinedCurveFontNames: + SCOPE = "entity" + TYPE_NAME = "IfcDraughtingPreDefinedCurveFont" + RULE_NAME = "PreDefinedCurveFontNames" + + @staticmethod + def __call__(self): + + + assert self.Name in ['continuous','chain','chaindoubledash','dashed','dotted','bylayer'] + + + + + +class IfcDuctFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcductfittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcductsegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcDuctSilencer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcDuctSilencer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcductsilencertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcDuctSilencerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcDuctSilencerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcDuctSilencerTypeEnum.USERDEFINED) or ((predefinedtype == IfcDuctSilencerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEarthworksCut_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEarthworksCut" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEarthworksCutTypeEnum.USERDEFINED) or ((predefinedtype == IfcEarthworksCutTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcEarthworksFill_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEarthworksFill" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEarthworksFillTypeEnum.USERDEFINED) or ((predefinedtype == IfcEarthworksFillTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcEdgeLoop_IsClosed: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsClosed" + + @staticmethod + def __call__(self): + edgelist = self.EdgeList + ne = self.Ne + + assert (edgelist[1 - 1].EdgeStart) == (edgelist[ne - 1].EdgeEnd) + + + + +class IfcEdgeLoop_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcEdgeLoop" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcLoopHeadToTail(self) + + + + +def calc_IfcEdgeLoop_Ne(self): + edgelist = self.EdgeList + return \ + sizeof(edgelist) + + + + +class IfcElectricAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcelectricappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricDistributionBoard_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricDistributionBoard_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoard" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcelectricdistributionboardtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricDistributionBoardType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricDistributionBoardType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricDistributionBoardTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricDistributionBoardTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowStorageDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowStorageDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcelectricflowstoragedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowStorageDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowStorageDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricFlowTreatmentDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricFlowTreatmentDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcelectricflowtreatmentdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricFlowTreatmentDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricFlowTreatmentDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricFlowTreatmentDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricGenerator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricGenerator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGenerator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcelectricgeneratortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricGeneratorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricGeneratorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricGeneratorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricGeneratorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricMotor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricMotor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcelectricmotortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricMotorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricMotorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricMotorTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricMotorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcElectricTimeControl_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElectricTimeControl_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControl" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcelectrictimecontroltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElectricTimeControlType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElectricTimeControlType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElectricTimeControlTypeEnum.USERDEFINED) or ((predefinedtype == IfcElectricTimeControlTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcElementAssembly_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcElementAssembly_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssembly" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcelementassemblytype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcElementAssemblyType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcElementAssemblyType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcElementAssemblyTypeEnum.USERDEFINED) or ((predefinedtype == IfcElementAssemblyTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcElementQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcElementQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + quantities = self.Quantities + + assert IfcUniqueQuantityNames(quantities) + + + + + + + + + + + + + + + + + + + + + + + +class IfcEngine_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEngine_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEngine" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcenginetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEngineType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEngineType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEngineTypeEnum.USERDEFINED) or ((predefinedtype == IfcEngineTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporativeCooler_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporativeCooler_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCooler" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcevaporativecoolertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporativeCoolerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporativeCoolerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporativeCoolerTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporativeCoolerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvaporator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvaporator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcevaporatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcEvaporatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvaporatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEvaporatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcEvaporatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcEvent_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcEvent_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcEvent" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (not exists(eventtriggertype)) or (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + + + + + +class IfcEventType_CorrectEventTriggerType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectEventTriggerType" + + @staticmethod + def __call__(self): + eventtriggertype = self.EventTriggerType + userdefinedeventtriggertype = self.UserDefinedEventTriggerType + + assert (eventtriggertype != IfcEventTriggerTypeEnum.USERDEFINED) or ((eventtriggertype == IfcEventTriggerTypeEnum.USERDEFINED) and exists(userdefinedeventtriggertype)) + + + + +class IfcEventType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcEventType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcEventTypeEnum.USERDEFINED) or ((predefinedtype == IfcEventTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + + + + + + + +class IfcExternalReference_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcExternalReference" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + location = self.Location + identification = self.Identification + name = self.Name + + assert exists(identification) or exists(location) or exists(name) + + + + + + + + + + + + + + + + + + + + + + + +class IfcExtrudedAreaSolid_ValidExtrusionDirection: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolid" + RULE_NAME = "ValidExtrusionDirection" + + @staticmethod + def __call__(self): + + + assert IfcDotProduct(IfcDirection(DirectionRatios=[0.0,0.0,1.0]),self.ExtrudedDirection) != 0.0 + + + + + +class IfcExtrudedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcExtrudedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + +class IfcFace_HasOuterBound: + SCOPE = "entity" + TYPE_NAME = "IfcFace" + RULE_NAME = "HasOuterBound" + + @staticmethod + def __call__(self): + bounds = self.Bounds + + assert (sizeof([temp for temp in bounds if 'ifc4x3_tc1.ifcfaceouterbound' in typeof(temp)])) <= 1 + + + + + +def calc_IfcFaceBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFacilityPartCommon_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFacilityPartCommon" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFacilityPartCommonTypeEnum.USERDEFINED) or ((predefinedtype == IfcFacilityPartCommonTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcFan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFan_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFan" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcfantype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFanType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFanType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFanTypeEnum.USERDEFINED) or ((predefinedtype == IfcFanTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFeatureElement_NotContained: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElement" + RULE_NAME = "NotContained" + + @staticmethod + def __call__(self): + containedinstructure = self.ContainedInStructure + + assert sizeof(containedinstructure) == 0 + + + + + + + + +class IfcFeatureElementSubtraction_HasNoSubtraction: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "HasNoSubtraction" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasOpenings) == 0 + + + + +class IfcFeatureElementSubtraction_IsNotFilling: + SCOPE = "entity" + TYPE_NAME = "IfcFeatureElementSubtraction" + RULE_NAME = "IsNotFilling" + + @staticmethod + def __call__(self): + + + assert sizeof(self.FillsVoids) == 0 + + + + + +class IfcFillAreaStyle_ConsistentHatchStyleDef: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "ConsistentHatchStyleDef" + + @staticmethod + def __call__(self): + + + assert IfcCorrectFillAreaStyle(self.FillStyles) + + + + +class IfcFillAreaStyle_MaxOneColour: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneColour" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x3_tc1.ifccolour' in typeof(style)])) <= 1 + + + + +class IfcFillAreaStyle_MaxOneExtHatchStyle: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyle" + RULE_NAME = "MaxOneExtHatchStyle" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.FillStyles if 'ifc4x3_tc1.ifcexternallydefinedhatchstyle' in typeof(style)])) <= 1 + + + + + +class IfcFillAreaStyleHatching_PatternStart2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "PatternStart2D" + + @staticmethod + def __call__(self): + patternstart = self.PatternStart + + assert (not exists(patternstart)) or (patternstart.Dim == 2) + + + + +class IfcFillAreaStyleHatching_RefHatchLine2D: + SCOPE = "entity" + TYPE_NAME = "IfcFillAreaStyleHatching" + RULE_NAME = "RefHatchLine2D" + + @staticmethod + def __call__(self): + pointofreferencehatchline = self.PointOfReferenceHatchLine + + assert (not exists(pointofreferencehatchline)) or (pointofreferencehatchline.Dim == 2) + + + + + + + + +class IfcFilter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFilter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFilter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcfiltertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFilterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFilterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFilterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFilterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFireSuppressionTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFireSuppressionTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcfiresuppressionterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFireSuppressionTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFireSuppressionTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFireSuppressionTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcFireSuppressionTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + +class IfcFlowInstrument_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowInstrument_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrument" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcflowinstrumenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowInstrumentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowInstrumentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowInstrumentTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowInstrumentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcFlowMeter_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFlowMeter_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeter" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcflowmetertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFlowMeterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFlowMeterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFlowMeterTypeEnum.USERDEFINED) or ((predefinedtype == IfcFlowMeterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcFooting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFooting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFooting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcfootingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFootingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFootingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcFootingTypeEnum.USERDEFINED) or ((predefinedtype == IfcFootingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcFurniture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcFurniture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcFurniture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcfurnituretype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcFurnitureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcFurnitureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcFurnitureTypeEnum.USERDEFINED) or ((predefinedtype == IfcFurnitureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeographicElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcGeographicElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcgeographicelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcGeographicElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeographicElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcGeographicElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeographicElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcGeometricCurveSet_NoSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricCurveSet" + RULE_NAME = "NoSurfaces" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Elements if 'ifc4x3_tc1.ifcsurface' in typeof(temp)])) == 0 + + + + + +class IfcGeometricRepresentationContext_North2D: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationContext" + RULE_NAME = "North2D" + + @staticmethod + def __call__(self): + truenorth = self.TrueNorth + + assert (not exists(truenorth)) or (hiindex(truenorth.DirectionRatios) == 2) + + + + + + + + +class IfcGeometricRepresentationSubContext_NoCoordOperation: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "NoCoordOperation" + + @staticmethod + def __call__(self): + + + assert sizeof(self.HasCoordinateOperation) == 0 + + + + +class IfcGeometricRepresentationSubContext_ParentNoSub: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "ParentNoSub" + + @staticmethod + def __call__(self): + parentcontext = self.ParentContext + + assert not 'ifc4x3_tc1.ifcgeometricrepresentationsubcontext' in typeof(parentcontext) + + + + +class IfcGeometricRepresentationSubContext_UserTargetProvided: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricRepresentationSubContext" + RULE_NAME = "UserTargetProvided" + + @staticmethod + def __call__(self): + targetview = self.TargetView + userdefinedtargetview = self.UserDefinedTargetView + + assert (targetview != IfcGeometricProjectionEnum.USERDEFINED) or ((targetview == IfcGeometricProjectionEnum.USERDEFINED) and exists(userdefinedtargetview)) + + + + +def calc_IfcGeometricRepresentationSubContext_WorldCoordinateSystem(self): + parentcontext = self.ParentContext + return \ + parentcontext.WorldCoordinateSystem + + + +def calc_IfcGeometricRepresentationSubContext_CoordinateSpaceDimension(self): + parentcontext = self.ParentContext + return \ + parentcontext.CoordinateSpaceDimension + + + +def calc_IfcGeometricRepresentationSubContext_TrueNorth(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.TrueNorth,IfcConvertDirectionInto2D(self.WorldCoordinateSystem.P[2 - 1])) + + + +def calc_IfcGeometricRepresentationSubContext_Precision(self): + parentcontext = self.ParentContext + return \ + nvl(parentcontext.Precision,1) + + + + +class IfcGeometricSet_ConsistentDim: + SCOPE = "entity" + TYPE_NAME = "IfcGeometricSet" + RULE_NAME = "ConsistentDim" + + @staticmethod + def __call__(self): + elements = self.Elements + + assert (sizeof([temp for temp in elements if temp.Dim != (elements[1 - 1].Dim)])) == 0 + + + + +def calc_IfcGeometricSet_Dim(self): + elements = self.Elements + return \ + elements[1 - 1].Dim + + + + + + + + + + + + + + + + +class IfcGeotechnicalStratum_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcGeotechnicalStratum" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcGeotechnicalStratumTypeEnum.USERDEFINED) or ((predefinedtype == IfcGeotechnicalStratumTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcGridAxis_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + axiscurve = self.AxisCurve + + assert axiscurve.Dim == 2 + + + + +class IfcGridAxis_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcGridAxis" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + partofw = self.PartOfW + partofv = self.PartOfV + partofu = self.PartOfU + + assert (sizeof(partofu) == 1) ^ (sizeof(partofv) == 1) ^ (sizeof(partofw) == 1) + + + + + + + + + + + +def calc_IfcHalfSpaceSolid_Dim(self): + + return \ + 3 + + + + +class IfcHeatExchanger_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHeatExchanger_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchanger" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcheatexchangertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHeatExchangerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHeatExchangerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHeatExchangerTypeEnum.USERDEFINED) or ((predefinedtype == IfcHeatExchangerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcHumidifier_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcHumidifier_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifier" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifchumidifiertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcHumidifierType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcHumidifierType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcHumidifierTypeEnum.USERDEFINED) or ((predefinedtype == IfcHumidifierTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIShapeProfileDef_ValidFilletRadius: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFilletRadius" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + overalldepth = self.OverallDepth + webthickness = self.WebThickness + flangethickness = self.FlangeThickness + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or ((filletradius <= ((overallwidth - webthickness) / 2.)) and (filletradius <= ((overalldepth - (2. * flangethickness)) / 2.))) + + + + +class IfcIShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + overalldepth = self.OverallDepth + flangethickness = self.FlangeThickness + + assert (2. * flangethickness) < overalldepth + + + + +class IfcIShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcIShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + overallwidth = self.OverallWidth + webthickness = self.WebThickness + + assert webthickness < overallwidth + + + + + + + + +class IfcImpactProtectionDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcImpactProtectionDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcImpactProtectionDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcimpactprotectiondevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcImpactProtectionDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcImpactProtectionDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcImpactProtectionDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcImpactProtectionDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcIndexedPolyCurve_Consecutive: + SCOPE = "entity" + TYPE_NAME = "IfcIndexedPolyCurve" + RULE_NAME = "Consecutive" + + @staticmethod + def __call__(self): + segments = self.Segments + + assert (not exists(segments)) or IfcConsecutiveSegments(segments) + + + + + + + + + + + + + + + + + + + + +class IfcInterceptor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcInterceptor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcinterceptortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcInterceptorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcInterceptorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcInterceptorTypeEnum.USERDEFINED) or ((predefinedtype == IfcInterceptorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcIntersectionCurve_DistinctSurfaces: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "DistinctSurfaces" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) != (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + +class IfcIntersectionCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcIntersectionCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + + + + + + + + + + + +class IfcJunctionBox_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcJunctionBox_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBox" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcjunctionboxtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcJunctionBoxType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcJunctionBoxType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcJunctionBoxTypeEnum.USERDEFINED) or ((predefinedtype == IfcJunctionBoxTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcKerb_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcKerb" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcKerbTypeEnum.USERDEFINED) or ((predefinedtype == IfcKerbTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcKerb_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcKerb" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifckerbtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcKerbType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcKerbType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcKerbTypeEnum.USERDEFINED) or ((predefinedtype == IfcKerbTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcLShapeProfileDef_ValidThickness: + SCOPE = "entity" + TYPE_NAME = "IfcLShapeProfileDef" + RULE_NAME = "ValidThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + width = self.Width + thickness = self.Thickness + + assert (thickness < depth) and ((not exists(width)) or (thickness < width)) + + + + + +class IfcLaborResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcLaborResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLaborResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLaborResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcLaborResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +class IfcLamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifclamptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLampTypeEnum.USERDEFINED) or ((predefinedtype == IfcLampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcLightFixture_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLightFixture_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixture" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifclightfixturetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLightFixtureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLightFixtureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLightFixtureTypeEnum.USERDEFINED) or ((predefinedtype == IfcLightFixtureTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcLine_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcLine" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + pnt = self.Pnt + dir = self.Dir + + assert dir.Dim == pnt.Dim + + + + + + + + + + + + + + +class IfcLiquidTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcLiquidTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcLiquidTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcLiquidTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcliquidterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcLiquidTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcLiquidTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcLiquidTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcLiquidTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcLocalPlacement_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcLocalPlacement" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + placementrelto = self.PlacementRelTo + relativeplacement = self.RelativePlacement + + assert IfcCorrectLocalPlacement(relativeplacement,placementrelto) + + + + + + + + + + + + + + + + + +class IfcMarineFacility_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMarineFacility" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMarineFacilityTypeEnum.USERDEFINED) or ((predefinedtype == IfcMarineFacilityTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcMarinePart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMarinePart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMarinePartTypeEnum.USERDEFINED) or ((predefinedtype == IfcMarinePartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + + + + + + + + + + +class IfcMaterialDefinitionRepresentation_OnlyStyledRepresentations: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialDefinitionRepresentation" + RULE_NAME = "OnlyStyledRepresentations" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x3_tc1.ifcstyledrepresentation' in typeof(temp)])) == 0 + + + + + +class IfcMaterialLayer_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialLayer" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + +def calc_IfcMaterialLayerSet_TotalThickness(self): + + return \ + IfcMlsTotalThickness(self) + + + + + + + + + + + + + +class IfcMaterialProfile_NormalizedPriority: + SCOPE = "entity" + TYPE_NAME = "IfcMaterialProfile" + RULE_NAME = "NormalizedPriority" + + @staticmethod + def __call__(self): + priority = self.Priority + + assert (not exists(priority)) or (0 <= priority <= 100) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcMechanicalFastener_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMechanicalFastener_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastener" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcmechanicalfastenertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMechanicalFastenerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMechanicalFastenerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMechanicalFastenerTypeEnum.USERDEFINED) or ((predefinedtype == IfcMechanicalFastenerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMedicalDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMedicalDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcmedicaldevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMedicalDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMedicalDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMedicalDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMedicalDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMember_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMember_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMember" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcmembertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMemberType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMemberType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMemberTypeEnum.USERDEFINED) or ((predefinedtype == IfcMemberTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +def calc_IfcMirroredProfileDef_Operator(self): + + return \ + IfcCartesianTransformationOperator2D(Axis1=IfcDirection(DirectionRatios=[-1.,0.]), Axis2=IfcDirection(DirectionRatios=[0.,1.]), LocalOrigin=IfcCartesianPoint(Coordinates=[0.,0.]), Scale=1.) + + + + +class IfcMobileTelecommunicationsAppliance_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsAppliance" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMobileTelecommunicationsAppliance_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsAppliance" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcmobiletelecommunicationsappliancetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMobileTelecommunicationsApplianceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMobileTelecommunicationsApplianceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMobileTelecommunicationsApplianceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcMooringDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMooringDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMooringDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMooringDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcmooringdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMooringDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMooringDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMooringDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcMooringDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcMotorConnection_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcMotorConnection_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnection" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcmotorconnectiontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcMotorConnectionType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcMotorConnectionType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcMotorConnectionTypeEnum.USERDEFINED) or ((predefinedtype == IfcMotorConnectionTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcNamedUnit_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcNamedUnit" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert IfcCorrectDimensions(self.UnitType,self.Dimensions) + + + + + +class IfcNavigationElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcNavigationElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcNavigationElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcNavigationElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcnavigationelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcNavigationElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcNavigationElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcNavigationElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcNavigationElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + isdefinedby = self.IsDefinedBy + + assert (sizeof(isdefinedby) == 0) or IfcUniqueDefinitionNames(isdefinedby) + + + + + + + + + + + +class IfcObjective_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcObjective" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + objectivequalifier = self.ObjectiveQualifier + + assert (objectivequalifier != IfcObjectiveEnum.USERDEFINED) or ((objectivequalifier == IfcObjectiveEnum.USERDEFINED) and exists(self.UserDefinedQualifier)) + + + + + +class IfcOccupant_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcOccupant" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not predefinedtype == IfcOccupantTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcOffsetCurve2D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve2D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 2 + + + + + +class IfcOffsetCurve3D_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcOffsetCurve3D" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert basiscurve.Dim == 3 + + + + + + + + +class IfcOpenCrossProfileDef_CorrectProfileType: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrectProfileType" + + @staticmethod + def __call__(self): + + + assert self.ProfileType == IfcProfileTypeEnum.CURVE + + + + +class IfcOpenCrossProfileDef_CorrespondingSlopeWidths: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrespondingSlopeWidths" + + @staticmethod + def __call__(self): + widths = self.Widths + slopes = self.Slopes + + assert sizeof(slopes) == sizeof(widths) + + + + +class IfcOpenCrossProfileDef_CorrespondingTags: + SCOPE = "entity" + TYPE_NAME = "IfcOpenCrossProfileDef" + RULE_NAME = "CorrespondingTags" + + @staticmethod + def __call__(self): + slopes = self.Slopes + tags = self.Tags + + assert (not exists(tags)) or (sizeof(tags) == (sizeof(slopes) + 1)) + + + + + + + + +class IfcOpeningElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOpeningElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcOpeningElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcOpeningElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcOrientedEdge_EdgeElementNotOriented: + SCOPE = "entity" + TYPE_NAME = "IfcOrientedEdge" + RULE_NAME = "EdgeElementNotOriented" + + @staticmethod + def __call__(self): + edgeelement = self.EdgeElement + + assert not 'ifc4x3_tc1.ifcorientededge' in typeof(edgeelement) + + + + +def calc_IfcOrientedEdge_EdgeStart(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeStart,edgeelement.EdgeEnd) + + + +def calc_IfcOrientedEdge_EdgeEnd(self): + edgeelement = self.EdgeElement + orientation = self.Orientation + return \ + IfcBooleanChoose(orientation,edgeelement.EdgeEnd,edgeelement.EdgeStart) + + + + + + + +class IfcOutlet_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcOutlet_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcOutlet" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcoutlettype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcOutletType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcOutletType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcOutletTypeEnum.USERDEFINED) or ((predefinedtype == IfcOutletTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcOwnerHistory_CorrectChangeAction: + SCOPE = "entity" + TYPE_NAME = "IfcOwnerHistory" + RULE_NAME = "CorrectChangeAction" + + @staticmethod + def __call__(self): + changeaction = self.ChangeAction + lastmodifieddate = self.LastModifiedDate + + assert exists(lastmodifieddate) or ((not exists(lastmodifieddate)) and (not exists(changeaction))) or ((not exists(lastmodifieddate)) and exists(changeaction) and ((changeaction == IfcChangeActionEnum.NOTDEFINED) or (changeaction == IfcChangeActionEnum.NOCHANGE))) + + + + + + + + +class IfcPath_IsContinuous: + SCOPE = "entity" + TYPE_NAME = "IfcPath" + RULE_NAME = "IsContinuous" + + @staticmethod + def __call__(self): + + + assert IfcPathHeadToTail(self) + + + + + +class IfcPavement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPavement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPavementTypeEnum.USERDEFINED) or ((predefinedtype == IfcPavementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPavement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPavement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcpavementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPavementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPavementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPavementTypeEnum.USERDEFINED) or ((predefinedtype == IfcPavementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPcurve_DimIs2D: + SCOPE = "entity" + TYPE_NAME = "IfcPcurve" + RULE_NAME = "DimIs2D" + + @staticmethod + def __call__(self): + referencecurve = self.ReferenceCurve + + assert referencecurve.Dim == 2 + + + + + + + + + + + + + + +class IfcPerson_IdentifiablePerson: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "IdentifiablePerson" + + @staticmethod + def __call__(self): + identification = self.Identification + familyname = self.FamilyName + givenname = self.GivenName + + assert exists(identification) or exists(familyname) or exists(givenname) + + + + +class IfcPerson_ValidSetOfNames: + SCOPE = "entity" + TYPE_NAME = "IfcPerson" + RULE_NAME = "ValidSetOfNames" + + @staticmethod + def __call__(self): + familyname = self.FamilyName + givenname = self.GivenName + middlenames = self.MiddleNames + + assert (not exists(middlenames)) or exists(familyname) or exists(givenname) + + + + + + + + +class IfcPhysicalComplexQuantity_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert (sizeof([temp for temp in hasquantities if self == temp])) == 0 + + + + +class IfcPhysicalComplexQuantity_UniqueQuantityNames: + SCOPE = "entity" + TYPE_NAME = "IfcPhysicalComplexQuantity" + RULE_NAME = "UniqueQuantityNames" + + @staticmethod + def __call__(self): + hasquantities = self.HasQuantities + + assert IfcUniqueQuantityNames(hasquantities) + + + + + + + + + + + +class IfcPile_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPile_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPile" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcpiletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPileType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPileType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPileTypeEnum.USERDEFINED) or ((predefinedtype == IfcPileTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeFitting_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeFitting_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFitting" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcpipefittingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeFittingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeFittingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeFittingTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeFittingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPipeSegment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPipeSegment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcpipesegmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPipeSegmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPipeSegmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPipeSegmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcPipeSegmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPixelTexture_MinPixelInS: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInS" + + @staticmethod + def __call__(self): + width = self.Width + + assert width >= 1 + + + + +class IfcPixelTexture_MinPixelInT: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "MinPixelInT" + + @staticmethod + def __call__(self): + height = self.Height + + assert height >= 1 + + + + +class IfcPixelTexture_NumberOfColours: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "NumberOfColours" + + @staticmethod + def __call__(self): + colourcomponents = self.ColourComponents + + assert 1 <= colourcomponents <= 4 + + + + +class IfcPixelTexture_PixelAsByteAndSameLength: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "PixelAsByteAndSameLength" + + @staticmethod + def __call__(self): + pixel = self.Pixel + + assert (sizeof([temp for temp in pixel if ((blength(temp) % 8) == 0) and (blength(temp) == (blength(pixel[1 - 1])))])) == sizeof(pixel) + + + + +class IfcPixelTexture_SizeOfPixelList: + SCOPE = "entity" + TYPE_NAME = "IfcPixelTexture" + RULE_NAME = "SizeOfPixelList" + + @staticmethod + def __call__(self): + width = self.Width + height = self.Height + pixel = self.Pixel + + assert sizeof(pixel) == (width * height) + + + + + +def calc_IfcPlacement_Dim(self): + location = self.Location + return \ + location.Dim + + + + + + + + + + + + + +class IfcPlate_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPlate_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPlate" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcplatetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPlateType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPlateType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPlateTypeEnum.USERDEFINED) or ((predefinedtype == IfcPlateTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcPoint_Dim(self): + + return \ + IfcPointDim(self) + + + + + + + + + + + + + +class IfcPolyLoop_AllPointsSameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyLoop" + RULE_NAME = "AllPointsSameDim" + + @staticmethod + def __call__(self): + polygon = self.Polygon + + assert (sizeof([temp for temp in polygon if temp.Dim != (polygon[1 - 1].Dim)])) == 0 + + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryDim" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert polygonalboundary.Dim == 2 + + + + +class IfcPolygonalBoundedHalfSpace_BoundaryType: + SCOPE = "entity" + TYPE_NAME = "IfcPolygonalBoundedHalfSpace" + RULE_NAME = "BoundaryType" + + @staticmethod + def __call__(self): + polygonalboundary = self.PolygonalBoundary + + assert (sizeof(typeof(polygonalboundary) * ['ifc4x3_tc1.ifcpolyline','ifc4x3_tc1.ifccompositecurve','ifc4x3_tc1.ifcindexedpolycurve'])) == 1 + + + + + + + + +class IfcPolyline_SameDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolyline" + RULE_NAME = "SameDim" + + @staticmethod + def __call__(self): + points = self.Points + + assert (sizeof([temp for temp in points if temp.Dim != (points[1 - 1].Dim)])) == 0 + + + + + +class IfcPolynomialCurve_CorrectPositionDim: + SCOPE = "entity" + TYPE_NAME = "IfcPolynomialCurve" + RULE_NAME = "CorrectPositionDim" + + @staticmethod + def __call__(self): + position = self.Position + coefficientsz = self.CoefficientsZ + + assert ((position.Dim == 2) and (not exists(coefficientsz))) or (position.Dim == 3) + + + + +class IfcPolynomialCurve_ValidCoefficients: + SCOPE = "entity" + TYPE_NAME = "IfcPolynomialCurve" + RULE_NAME = "ValidCoefficients" + + @staticmethod + def __call__(self): + coefficientsx = self.CoefficientsX + coefficientsy = self.CoefficientsY + coefficientsz = self.CoefficientsZ + + assert (exists(coefficientsx) and exists(coefficientsy)) or (exists(coefficientsx) and exists(coefficientsz)) or (exists(coefficientsy) and exists(coefficientsz)) or (exists(coefficientsx) and exists(coefficientsy) and exists(coefficientsz)) + + + + + + + + +class IfcPositioningElement_HasPlacement: + SCOPE = "entity" + TYPE_NAME = "IfcPositioningElement" + RULE_NAME = "HasPlacement" + + @staticmethod + def __call__(self): + + + assert exists(self.ObjectPlacement) + + + + + +class IfcPostalAddress_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcPostalAddress" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + internallocation = self.InternalLocation + addresslines = self.AddressLines + postalbox = self.PostalBox + town = self.Town + region = self.Region + postalcode = self.PostalCode + country = self.Country + + assert exists(internallocation) or exists(addresslines) or exists(postalbox) or exists(postalcode) or exists(town) or exists(region) or exists(country) + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcPresentationLayerAssignment_ApplicableItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerAssignment" + RULE_NAME = "ApplicableItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x3_tc1.ifcshaperepresentation','ifc4x3_tc1.ifcgeometricrepresentationitem','ifc4x3_tc1.ifcmappeditem'])) == 1])) == sizeof(assigneditems) + + + + + +class IfcPresentationLayerWithStyle_ApplicableOnlyToItems: + SCOPE = "entity" + TYPE_NAME = "IfcPresentationLayerWithStyle" + RULE_NAME = "ApplicableOnlyToItems" + + @staticmethod + def __call__(self): + assigneditems = self.AssignedItems + + assert (sizeof([temp for temp in assigneditems if (sizeof(typeof(temp) * ['ifc4x3_tc1.ifcgeometricrepresentationitem','ifc4x3_tc1.ifcmappeditem'])) >= 1])) == sizeof(assigneditems) + + + + + + + + +class IfcProcedure_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProcedure_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProcedure" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + +class IfcProcedureType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProcedureType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProcedureTypeEnum.USERDEFINED) or ((predefinedtype == IfcProcedureTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + + + + +class IfcProduct_PlacementForShapeRepresentation: + SCOPE = "entity" + TYPE_NAME = "IfcProduct" + RULE_NAME = "PlacementForShapeRepresentation" + + @staticmethod + def __call__(self): + objectplacement = self.ObjectPlacement + representation = self.Representation + + assert (exists(representation) and exists(objectplacement)) or (exists(representation) and ((sizeof([temp for temp in representation.Representations if 'ifc4x3_tc1.ifcshaperepresentation' in typeof(temp)])) == 0)) or (not exists(representation)) + + + + + +class IfcProductDefinitionShape_OnlyShapeModel: + SCOPE = "entity" + TYPE_NAME = "IfcProductDefinitionShape" + RULE_NAME = "OnlyShapeModel" + + @staticmethod + def __call__(self): + representations = self.Representations + + assert (sizeof([temp for temp in representations if not 'ifc4x3_tc1.ifcshapemodel' in typeof(temp)])) == 0 + + + + + + + + + + + + + + +class IfcProject_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert (not exists(self.RepresentationContexts)) or ((sizeof([temp for temp in self.RepresentationContexts if 'ifc4x3_tc1.ifcgeometricrepresentationsubcontext' in typeof(temp)])) == 0) + + + + +class IfcProject_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcProject_NoDecomposition: + SCOPE = "entity" + TYPE_NAME = "IfcProject" + RULE_NAME = "NoDecomposition" + + @staticmethod + def __call__(self): + + + assert sizeof(self.Decomposes) == 0 + + + + + + + + + + + +class IfcProjectedCRS_IsLengthUnit: + SCOPE = "entity" + TYPE_NAME = "IfcProjectedCRS" + RULE_NAME = "IsLengthUnit" + + @staticmethod + def __call__(self): + mapunit = self.MapUnit + + assert (not exists(mapunit)) or (mapunit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + + +class IfcProjectionElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProjectionElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProjectionElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcProjectionElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcPropertyBoundedValue_SameUnitLowerSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitLowerSet" + + @staticmethod + def __call__(self): + lowerboundvalue = self.LowerBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(lowerboundvalue)) or (not exists(setpointvalue)) or (typeof(lowerboundvalue) == typeof(setpointvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitUpperLower: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperLower" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + lowerboundvalue = self.LowerBoundValue + + assert (not exists(upperboundvalue)) or (not exists(lowerboundvalue)) or (typeof(upperboundvalue) == typeof(lowerboundvalue)) + + + + +class IfcPropertyBoundedValue_SameUnitUpperSet: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyBoundedValue" + RULE_NAME = "SameUnitUpperSet" + + @staticmethod + def __call__(self): + upperboundvalue = self.UpperBoundValue + setpointvalue = self.SetPointValue + + assert (not exists(upperboundvalue)) or (not exists(setpointvalue)) or (typeof(upperboundvalue) == typeof(setpointvalue)) + + + + + + + + +class IfcPropertyDependencyRelationship_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyDependencyRelationship" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + dependingproperty = self.DependingProperty + dependantproperty = self.DependantProperty + + assert dependingproperty != dependantproperty + + + + + +class IfcPropertyEnumeratedValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeratedValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + enumerationvalues = self.EnumerationValues + enumerationreference = self.EnumerationReference + + assert (not exists(enumerationreference)) or (not exists(enumerationvalues)) or ((sizeof([temp for temp in enumerationvalues if temp in enumerationreference.EnumerationValues])) == sizeof(enumerationvalues)) + + + + + +class IfcPropertyEnumeration_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyEnumeration" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.EnumerationValues if not (typeof(self.EnumerationValues[1 - 1])) == typeof(temp)])) == 0 + + + + + +class IfcPropertyListValue_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyListValue" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.ListValues if not (typeof(self.ListValues[1 - 1])) == typeof(temp)])) == 0 + + + + + + + + +class IfcPropertySet_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySet_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySet" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + hasproperties = self.HasProperties + + assert IfcUniquePropertyName(hasproperties) + + + + + + + + +class IfcPropertySetTemplate_ExistsName: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "ExistsName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcPropertySetTemplate_UniquePropertyNames: + SCOPE = "entity" + TYPE_NAME = "IfcPropertySetTemplate" + RULE_NAME = "UniquePropertyNames" + + @staticmethod + def __call__(self): + haspropertytemplates = self.HasPropertyTemplates + + assert IfcUniquePropertyTemplateNames(haspropertytemplates) + + + + + + + + +class IfcPropertyTableValue_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + definedvalues = self.DefinedValues + + assert ((not exists(definingvalues)) and (not exists(definedvalues))) or (sizeof(definingvalues) == sizeof(definedvalues)) + + + + +class IfcPropertyTableValue_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + definingvalues = self.DefiningValues + + assert (not exists(definingvalues)) or ((sizeof([temp for temp in self.DefiningValues if typeof(temp) != (typeof(self.DefiningValues[1 - 1]))])) == 0) + + + + +class IfcPropertyTableValue_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcPropertyTableValue" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + definedvalues = self.DefinedValues + + assert (not exists(definedvalues)) or ((sizeof([temp for temp in self.DefinedValues if typeof(temp) != (typeof(self.DefinedValues[1 - 1]))])) == 0) + + + + + + + + + + + +class IfcProtectiveDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcprotectivedevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcProtectiveDeviceTrippingUnit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcprotectivedevicetrippingunittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcProtectiveDeviceTrippingUnitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceTrippingUnitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcProtectiveDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcProtectiveDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcProtectiveDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcProtectiveDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcPump_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcPump_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcPump" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcpumptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcPumpType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcPumpType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcPumpTypeEnum.USERDEFINED) or ((predefinedtype == IfcPumpTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcQuantityArea_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.AREAUNIT) + + + + +class IfcQuantityArea_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityArea" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + areavalue = self.AreaValue + + assert areavalue >= 0. + + + + + +class IfcQuantityCount_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityCount" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + countvalue = self.CountValue + + assert countvalue >= 0 + + + + + +class IfcQuantityLength_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.LENGTHUNIT) + + + + +class IfcQuantityLength_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityLength" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + lengthvalue = self.LengthValue + + assert lengthvalue >= 0. + + + + + + + + + + + +class IfcQuantityTime_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.TIMEUNIT) + + + + +class IfcQuantityTime_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityTime" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + timevalue = self.TimeValue + + assert timevalue >= 0. + + + + + +class IfcQuantityVolume_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.VOLUMEUNIT) + + + + +class IfcQuantityVolume_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityVolume" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + volumevalue = self.VolumeValue + + assert volumevalue >= 0. + + + + + +class IfcQuantityWeight_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (not exists(self.Unit)) or (self.Unit.UnitType == IfcUnitEnum.MASSUNIT) + + + + +class IfcQuantityWeight_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcQuantityWeight" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + weightvalue = self.WeightValue + + assert weightvalue >= 0. + + + + + +class IfcRail_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRail" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRail_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRail" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcrailtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRailing_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRailing_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRailing" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcrailingtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRailingType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailingType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRailingTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailingTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRailway_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailway" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailwayTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailwayTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcRailwayPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRailwayPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRailwayPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcRailwayPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcRamp_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRamp_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRamp" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcramptype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRampFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcrampflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRampFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRampType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRampType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRampTypeEnum.USERDEFINED) or ((predefinedtype == IfcRampTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcRationalBSplineCurveWithKnots_SameNumOfWeightsAndPoints: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "SameNumOfWeightsAndPoints" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert sizeof(weightsdata) == sizeof(self.ControlPointsList) + + + + +class IfcRationalBSplineCurveWithKnots_WeightsGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineCurveWithKnots" + RULE_NAME = "WeightsGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcCurveWeightsPositive(self) + + + + +def calc_IfcRationalBSplineCurveWithKnots_Weights(self): + weightsdata = self.WeightsData + return \ + IfcListToArray(weightsdata,0,self.UpperIndexOnControlPoints) + + + + +class IfcRationalBSplineSurfaceWithKnots_CorrespondingWeightsDataLists: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "CorrespondingWeightsDataLists" + + @staticmethod + def __call__(self): + weightsdata = self.WeightsData + + assert (sizeof(weightsdata) == sizeof(self.ControlPointsList)) and ((sizeof(weightsdata[1 - 1])) == (sizeof(self.ControlPointsList[1 - 1]))) + + + + +class IfcRationalBSplineSurfaceWithKnots_WeightValuesGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcRationalBSplineSurfaceWithKnots" + RULE_NAME = "WeightValuesGreaterZero" + + @staticmethod + def __call__(self): + + + assert IfcSurfaceWeightsPositive(self) + + + + +def calc_IfcRationalBSplineSurfaceWithKnots_Weights(self): + uupper = self.UUpper + vupper = self.VUpper + weightsdata = self.WeightsData + return \ + IfcMakeArrayOfArray(weightsdata,0,uupper,0,vupper) + + + + +class IfcRectangleHollowProfileDef_ValidInnerRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidInnerRadius" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + innerfilletradius = self.InnerFilletRadius + + assert (not exists(innerfilletradius)) or ((innerfilletradius <= ((self.XDim / 2.) - wallthickness)) and (innerfilletradius <= ((self.YDim / 2.) - wallthickness))) + + + + +class IfcRectangleHollowProfileDef_ValidOuterRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidOuterRadius" + + @staticmethod + def __call__(self): + outerfilletradius = self.OuterFilletRadius + + assert (not exists(outerfilletradius)) or ((outerfilletradius <= (self.XDim / 2.)) and (outerfilletradius <= (self.YDim / 2.))) + + + + +class IfcRectangleHollowProfileDef_ValidWallThickness: + SCOPE = "entity" + TYPE_NAME = "IfcRectangleHollowProfileDef" + RULE_NAME = "ValidWallThickness" + + @staticmethod + def __call__(self): + wallthickness = self.WallThickness + + assert (wallthickness < (self.XDim / 2.)) and (wallthickness < (self.YDim / 2.)) + + + + + + + + + + + +class IfcRectangularTrimmedSurface_U1AndU2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "U1AndU2Different" + + @staticmethod + def __call__(self): + u1 = self.U1 + u2 = self.U2 + + assert u1 != u2 + + + + +class IfcRectangularTrimmedSurface_UsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "UsenseCompatible" + + @staticmethod + def __call__(self): + basissurface = self.BasisSurface + u1 = self.U1 + u2 = self.U2 + usense = self.Usense + + assert (('ifc4x3_tc1.ifcelementarysurface' in typeof(basissurface)) and (not 'ifc4x3_tc1.ifcplane' in typeof(basissurface))) or ('ifc4x3_tc1.ifcsurfaceofrevolution' in typeof(basissurface)) or (usense == (u2 > u1)) + + + + +class IfcRectangularTrimmedSurface_V1AndV2Different: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "V1AndV2Different" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + + assert v1 != v2 + + + + +class IfcRectangularTrimmedSurface_VsenseCompatible: + SCOPE = "entity" + TYPE_NAME = "IfcRectangularTrimmedSurface" + RULE_NAME = "VsenseCompatible" + + @staticmethod + def __call__(self): + v1 = self.V1 + v2 = self.V2 + vsense = self.Vsense + + assert vsense == (v2 > v1) + + + + + + + + + + + + + + + + + +class IfcReinforcedSoil_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcedSoil" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcedSoilTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcedSoilTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcReinforcingBar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingBar_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBar" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcreinforcingbartype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingBarType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + +class IfcReinforcingBarType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingBarType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingBarTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingBarTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcReinforcingMesh_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcReinforcingMesh_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMesh" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcreinforcingmeshtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcReinforcingMeshType_BendingShapeCodeProvided: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "BendingShapeCodeProvided" + + @staticmethod + def __call__(self): + bendingshapecode = self.BendingShapeCode + bendingparameters = self.BendingParameters + + assert (not exists(bendingparameters)) or exists(bendingshapecode) + + + + +class IfcReinforcingMeshType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcReinforcingMeshType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcReinforcingMeshTypeEnum.USERDEFINED) or ((predefinedtype == IfcReinforcingMeshTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcRelAggregates_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAggregates" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + + + + +class IfcRelAssignsToActor_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToActor" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingactor = self.RelatingActor + + assert (sizeof([temp for temp in self.RelatedObjects if relatingactor == temp])) == 0 + + + + + +class IfcRelAssignsToControl_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToControl" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontrol = self.RelatingControl + + assert (sizeof([temp for temp in self.RelatedObjects if relatingcontrol == temp])) == 0 + + + + + +class IfcRelAssignsToGroup_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToGroup" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatinggroup = self.RelatingGroup + + assert (sizeof([temp for temp in self.RelatedObjects if relatinggroup == temp])) == 0 + + + + + + + + +class IfcRelAssignsToProcess_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProcess" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + + assert (sizeof([temp for temp in self.RelatedObjects if relatingprocess == temp])) == 0 + + + + + +class IfcRelAssignsToProduct_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToProduct" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingproduct = self.RelatingProduct + + assert (sizeof([temp for temp in self.RelatedObjects if relatingproduct == temp])) == 0 + + + + + +class IfcRelAssignsToResource_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssignsToResource" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingresource = self.RelatingResource + + assert (sizeof([temp for temp in self.RelatedObjects if relatingresource == temp])) == 0 + + + + + + + + + + + + + + + + + + + + + + + +class IfcRelAssociatesMaterial_AllowedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "AllowedElements" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if (sizeof(typeof(temp) * ['ifc4x3_tc1.ifcelement','ifc4x3_tc1.ifcelementtype','ifc4x3_tc1.ifcstructuralmember','ifc4x3_tc1.ifcport'])) == 0])) == 0 + + + + +class IfcRelAssociatesMaterial_NoVoidElement: + SCOPE = "entity" + TYPE_NAME = "IfcRelAssociatesMaterial" + RULE_NAME = "NoVoidElement" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.RelatedObjects if ('ifc4x3_tc1.ifcfeatureelementsubtraction' in typeof(temp)) or ('ifc4x3_tc1.ifcvirtualelement' in typeof(temp))])) == 0 + + + + + + + + + + + +class IfcRelConnectsElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelConnectsPathElements_NormalizedRelatedPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatedPriorities" + + @staticmethod + def __call__(self): + relatedpriorities = self.RelatedPriorities + + assert (sizeof(relatedpriorities) == 0) or ((sizeof([temp for temp in relatedpriorities if 0 <= temp <= 100])) == sizeof(relatedpriorities)) + + + + +class IfcRelConnectsPathElements_NormalizedRelatingPriorities: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPathElements" + RULE_NAME = "NormalizedRelatingPriorities" + + @staticmethod + def __call__(self): + relatingpriorities = self.RelatingPriorities + + assert (sizeof(relatingpriorities) == 0) or ((sizeof([temp for temp in relatingpriorities if 0 <= temp <= 100])) == sizeof(relatingpriorities)) + + + + + + + + +class IfcRelConnectsPorts_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelConnectsPorts" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingport = self.RelatingPort + relatedport = self.RelatedPort + + assert relatingport != relatedport + + + + + + + + + + + + + + + + + +class IfcRelContainedInSpatialStructure_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcRelContainedInSpatialStructure" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if 'ifc4x3_tc1.ifcspatialstructureelement' in typeof(temp)])) == 0 + + + + + + + + + + + +class IfcRelDeclares_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelDeclares" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingcontext = self.RelatingContext + relateddefinitions = self.RelatedDefinitions + + assert (sizeof([temp for temp in relateddefinitions if relatingcontext == temp])) == 0 + + + + + + + + + + + + + + +class IfcRelDefinesByProperties_NoRelatedTypeObject: + SCOPE = "entity" + TYPE_NAME = "IfcRelDefinesByProperties" + RULE_NAME = "NoRelatedTypeObject" + + @staticmethod + def __call__(self): + + + assert (sizeof([types for types in self.RelatedObjects if 'ifc4x3_tc1.ifctypeobject' in typeof(types)])) == 0 + + + + + + + + + + + + + + + + + +class IfcRelInterferesElements_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelInterferesElements" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingelement = self.RelatingElement + relatedelement = self.RelatedElement + + assert relatingelement != relatedelement + + + + + +class IfcRelNests_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelNests" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingobject = self.RelatingObject + relatedobjects = self.RelatedObjects + + assert (sizeof([temp for temp in relatedobjects if relatingobject == temp])) == 0 + + + + + +class IfcRelPositions_NoSelfReference: + SCOPE = "entity" + TYPE_NAME = "IfcRelPositions" + RULE_NAME = "NoSelfReference" + + @staticmethod + def __call__(self): + relatingpositioningelement = self.RelatingPositioningElement + relatedproducts = self.RelatedProducts + + assert (sizeof([temp for temp in relatedproducts if relatingpositioningelement == temp])) == 0 + + + + + + + + +class IfcRelReferencedInSpatialStructure_AllowedRelatedElements: + SCOPE = "entity" + TYPE_NAME = "IfcRelReferencedInSpatialStructure" + RULE_NAME = "AllowedRelatedElements" + + @staticmethod + def __call__(self): + relatedelements = self.RelatedElements + + assert (sizeof([temp for temp in relatedelements if ('ifc4x3_tc1.ifcspatialstructureelement' in typeof(temp)) and (not 'ifc4x3_tc1.ifcspace' in typeof(temp))])) == 0 + + + + + +class IfcRelSequence_AvoidInconsistentSequence: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "AvoidInconsistentSequence" + + @staticmethod + def __call__(self): + relatingprocess = self.RelatingProcess + relatedprocess = self.RelatedProcess + + assert relatingprocess != relatedprocess + + + + +class IfcRelSequence_CorrectSequenceType: + SCOPE = "entity" + TYPE_NAME = "IfcRelSequence" + RULE_NAME = "CorrectSequenceType" + + @staticmethod + def __call__(self): + sequencetype = self.SequenceType + userdefinedsequencetype = self.UserDefinedSequenceType + + assert (sequencetype != IfcSequenceEnum.USERDEFINED) or ((sequencetype == IfcSequenceEnum.USERDEFINED) and exists(userdefinedsequencetype)) + + + + + + + + +class IfcRelSpaceBoundary_CorrectPhysOrVirt: + SCOPE = "entity" + TYPE_NAME = "IfcRelSpaceBoundary" + RULE_NAME = "CorrectPhysOrVirt" + + @staticmethod + def __call__(self): + relatedbuildingelement = self.RelatedBuildingElement + physicalorvirtualboundary = self.PhysicalOrVirtualBoundary + + assert ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Physical) and (not 'ifc4x3_tc1.ifcvirtualelement' in typeof(relatedbuildingelement))) or ((physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.Virtual) and (('ifc4x3_tc1.ifcvirtualelement' in typeof(relatedbuildingelement)) or ('ifc4x3_tc1.ifcopeningelement' in typeof(relatedbuildingelement)))) or (physicalorvirtualboundary == IfcPhysicalOrVirtualEnum.NotDefined) + + + + + + + + + + + + + + + + + +class IfcReparametrisedCompositeCurveSegment_PositiveLengthParameter: + SCOPE = "entity" + TYPE_NAME = "IfcReparametrisedCompositeCurveSegment" + RULE_NAME = "PositiveLengthParameter" + + @staticmethod + def __call__(self): + paramlength = self.ParamLength + + assert paramlength > 0.0 + + + + + + + + + + + + + + +class IfcRepresentationMap_ApplicableMappedRepr: + SCOPE = "entity" + TYPE_NAME = "IfcRepresentationMap" + RULE_NAME = "ApplicableMappedRepr" + + @staticmethod + def __call__(self): + mappedrepresentation = self.MappedRepresentation + + assert 'ifc4x3_tc1.ifcshapemodel' in typeof(mappedrepresentation) + + + + + + + + + + + + + + + + + + + + +class IfcRevolvedAreaSolid_AxisDirectionInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisDirectionInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert (axis.Z.DirectionRatios[3 - 1]) == 0.0 + + + + +class IfcRevolvedAreaSolid_AxisStartInXY: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolid" + RULE_NAME = "AxisStartInXY" + + @staticmethod + def __call__(self): + axis = self.Axis + + assert ('ifc4x3_tc1.ifccartesianpoint' in typeof(axis.Location)) and ((axis.Location.Coordinates[3 - 1]) == 0.0) + + + + +def calc_IfcRevolvedAreaSolid_AxisLine(self): + axis = self.Axis + return \ + IfcLine(Pnt=axis.Location, Dir=IfcVector(Orientation=axis.Z, Magnitude=1.0)) + + + + +class IfcRevolvedAreaSolidTapered_CorrectProfileAssignment: + SCOPE = "entity" + TYPE_NAME = "IfcRevolvedAreaSolidTapered" + RULE_NAME = "CorrectProfileAssignment" + + @staticmethod + def __call__(self): + + + assert IfcTaperedSweptAreaProfiles(self.SweptArea,self.EndSweptArea) + + + + + + + + + + + +class IfcRoad_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoad" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoadTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoadTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcRoadPart_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoadPart" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoadPartTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoadPartTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcRoof_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcRoof_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcRoof" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcrooftype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcRoofType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcRoofType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcRoofTypeEnum.USERDEFINED) or ((predefinedtype == IfcRoofTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcRoundedRectangleProfileDef_ValidRadius: + SCOPE = "entity" + TYPE_NAME = "IfcRoundedRectangleProfileDef" + RULE_NAME = "ValidRadius" + + @staticmethod + def __call__(self): + roundingradius = self.RoundingRadius + + assert (roundingradius <= (self.XDim / 2.)) and (roundingradius <= (self.YDim / 2.)) + + + + + +def calc_IfcSIUnit_Dimensions(self): + + return \ + IfcDimensionsForSIUnit(self.Name) + + + + +class IfcSanitaryTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSanitaryTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcsanitaryterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSanitaryTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSanitaryTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSanitaryTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSanitaryTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSeamCurve_SameSurface: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "SameSurface" + + @staticmethod + def __call__(self): + + + assert (IfcAssociatedSurface(self.AssociatedGeometry[1 - 1])) == (IfcAssociatedSurface(self.AssociatedGeometry[2 - 1])) + + + + +class IfcSeamCurve_TwoPCurves: + SCOPE = "entity" + TYPE_NAME = "IfcSeamCurve" + RULE_NAME = "TwoPCurves" + + @staticmethod + def __call__(self): + + + assert sizeof(self.AssociatedGeometry) == 2 + + + + + + + + + + + + + + +class IfcSectionedSolid_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSolid_DirectrixIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "DirectrixIs3D" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSectionedSolid_SectionsSameType: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolid" + RULE_NAME = "SectionsSameType" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (typeof(crosssections[1 - 1])) != typeof(temp)])) == 0 + + + + + +class IfcSectionedSolidHorizontal_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSolidHorizontal_NoLongitudinalOffsets: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSolidHorizontal" + RULE_NAME = "NoLongitudinalOffsets" + + @staticmethod + def __call__(self): + crosssectionpositions = self.CrossSectionPositions + + assert (sizeof([temp for temp in crosssectionpositions if exists(temp.Location.OffsetLongitudinal)])) == 0 + + + + + +class IfcSectionedSpine_ConsistentProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "ConsistentProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (crosssections[1 - 1].ProfileType) != temp.ProfileType])) == 0 + + + + +class IfcSectionedSpine_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + crosssectionpositions = self.CrossSectionPositions + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSpine_SpineCurveDim: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSpine" + RULE_NAME = "SpineCurveDim" + + @staticmethod + def __call__(self): + spinecurve = self.SpineCurve + + assert spinecurve.Dim == 3 + + + + +def calc_IfcSectionedSpine_Dim(self): + + return \ + 3 + + + + +class IfcSectionedSurface_AreaProfileTypes: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSurface" + RULE_NAME = "AreaProfileTypes" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if temp.ProfileType == IfcProfileTypeEnum.CURVE])) == 0 + + + + +class IfcSectionedSurface_CorrespondingSectionPositions: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSurface" + RULE_NAME = "CorrespondingSectionPositions" + + @staticmethod + def __call__(self): + crosssectionpositions = self.CrossSectionPositions + crosssections = self.CrossSections + + assert sizeof(crosssections) == sizeof(crosssectionpositions) + + + + +class IfcSectionedSurface_DirectrixIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSurface" + RULE_NAME = "DirectrixIs3D" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSectionedSurface_NoOffsets: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSurface" + RULE_NAME = "NoOffsets" + + @staticmethod + def __call__(self): + crosssectionpositions = self.CrossSectionPositions + + assert (sizeof([temp for temp in crosssectionpositions if exists(temp.Location.OffsetLateral) or exists(temp.Location.OffsetVertical) or exists(temp.Location.OffsetLongitudinal)])) == 0 + + + + +class IfcSectionedSurface_SectionsSameType: + SCOPE = "entity" + TYPE_NAME = "IfcSectionedSurface" + RULE_NAME = "SectionsSameType" + + @staticmethod + def __call__(self): + crosssections = self.CrossSections + + assert (sizeof([temp for temp in crosssections if (typeof(crosssections[1 - 1])) != typeof(temp)])) == 0 + + + + + +def calc_IfcSegment_Dim(self): + + return \ + IfcSegmentDim(self) + + + + + + + +class IfcSensor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSensor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSensor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcsensortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSensorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSensorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSensorTypeEnum.USERDEFINED) or ((predefinedtype == IfcSensorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcShadingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcShadingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcshadingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcShadingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcShadingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcShadingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcShadingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcShapeModel_WR11: + SCOPE = "entity" + TYPE_NAME = "IfcShapeModel" + RULE_NAME = "WR11" + + @staticmethod + def __call__(self): + ofshapeaspect = self.OfShapeAspect + + assert (sizeof(self.OfProductRepresentation) == 1) ^ (sizeof(self.RepresentationMap) == 1) ^ (sizeof(ofshapeaspect) == 1) + + + + + +class IfcShapeRepresentation_CorrectContext: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectContext" + + @staticmethod + def __call__(self): + + + assert 'ifc4x3_tc1.ifcgeometricrepresentationcontext' in typeof(self.ContextOfItems) + + + + +class IfcShapeRepresentation_CorrectItemsForType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "CorrectItemsForType" + + @staticmethod + def __call__(self): + + + assert IfcShapeRepresentationTypes(self.RepresentationType,self.Items) + + + + +class IfcShapeRepresentation_HasRepresentationIdentifier: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationIdentifier" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationIdentifier) + + + + +class IfcShapeRepresentation_HasRepresentationType: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "HasRepresentationType" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcShapeRepresentation_NoTopologicalItem: + SCOPE = "entity" + TYPE_NAME = "IfcShapeRepresentation" + RULE_NAME = "NoTopologicalItem" + + @staticmethod + def __call__(self): + items = self.Items + + assert (sizeof([temp for temp in items if ('ifc4x3_tc1.ifctopologicalrepresentationitem' in typeof(temp)) and (not (sizeof(['ifc4x3_tc1.ifcvertexpoint','ifc4x3_tc1.ifcedgecurve','ifc4x3_tc1.ifcfacesurface'] * typeof(temp))) == 1)])) == 0 + + + + + +def calc_IfcShellBasedSurfaceModel_Dim(self): + + return \ + 3 + + + + +class IfcSign_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSign" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSignTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSign_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSign" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcsigntype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSignType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSignTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSignal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSignalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSignal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSignal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcsignaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSignalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSignalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSignalTypeEnum.USERDEFINED) or ((predefinedtype == IfcSignalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + + + + +class IfcSlab_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSlab_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSlab" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcslabtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSlabType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSlabType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSlabTypeEnum.USERDEFINED) or ((predefinedtype == IfcSlabTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSolarDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSolarDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcsolardevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSolarDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSolarDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSolarDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSolarDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcSolidModel_Dim(self): + + return \ + 3 + + + + +class IfcSpace_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpace_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpace" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcspacetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeater_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpaceHeater_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeater" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcspaceheatertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpaceHeaterType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceHeaterType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceHeaterTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceHeaterTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcSpaceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpaceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpaceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpaceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcSpatialStructureElement_WR41: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialStructureElement" + RULE_NAME = "WR41" + + @staticmethod + def __call__(self): + + + assert (hiindex(self.Decomposes) == 1) and ('ifc4x3_tc1.ifcrelaggregates' in (typeof(self.Decomposes[1 - 1]))) and (('ifc4x3_tc1.ifcproject' in (typeof(self.Decomposes[1 - 1].RelatingObject))) or ('ifc4x3_tc1.ifcspatialstructureelement' in (typeof(self.Decomposes[1 - 1].RelatingObject)))) + + + + + + + + +class IfcSpatialZone_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSpatialZone_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZone" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcspatialzonetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSpatialZoneType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSpatialZoneType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSpatialZoneTypeEnum.USERDEFINED) or ((predefinedtype == IfcSpatialZoneTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcStackTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStackTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcstackterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStackTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStackTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStackTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcStackTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStair_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStair_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStair" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcstairtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlight_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcStairFlight_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlight" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcstairflighttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcStairFlightType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairFlightType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairFlightTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairFlightTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcStairType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStairType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStairTypeEnum.USERDEFINED) or ((predefinedtype == IfcStairTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + +class IfcStructuralAnalysisModel_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralAnalysisModel" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcAnalysisModelTypeEnum.USERDEFINED) or ((predefinedtype == IfcAnalysisModelTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + + + + +class IfcStructuralCurveAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + +class IfcStructuralCurveAction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveAction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert predefinedtype != IfcStructuralCurveActivityTypeEnum.EQUIDISTANT + + + + + + + + +class IfcStructuralCurveMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralCurveReaction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralCurveReaction_SuitablePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralCurveReaction" + RULE_NAME = "SuitablePredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralCurveActivityTypeEnum.SINUS) and (predefinedtype != IfcStructuralCurveActivityTypeEnum.PARABOLA) + + + + + + + + +class IfcStructuralLinearAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralCurveActivityTypeEnum.CONST + + + + +class IfcStructuralLinearAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLinearAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_tc1.ifcstructuralloadlinearforce','ifc4x3_tc1.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralLoadCase_IsLoadCasePredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadCase" + RULE_NAME = "IsLoadCasePredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcLoadGroupTypeEnum.LOAD_CASE + + + + + +class IfcStructuralLoadConfiguration_ValidListSize: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadConfiguration" + RULE_NAME = "ValidListSize" + + @staticmethod + def __call__(self): + values = self.Values + locations = self.Locations + + assert (not exists(locations)) or (sizeof(locations) == sizeof(values)) + + + + + +class IfcStructuralLoadGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralLoadGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + actiontype = self.ActionType + actionsource = self.ActionSource + + assert ((predefinedtype != IfcLoadGroupTypeEnum.USERDEFINED) and (actiontype != IfcActionTypeEnum.USERDEFINED) and (actionsource != IfcActionSourceTypeEnum.USERDEFINED)) or exists(self.ObjectType) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcStructuralPlanarAction_ConstPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "ConstPredefinedType" + + @staticmethod + def __call__(self): + + + assert self.PredefinedType == IfcStructuralSurfaceActivityTypeEnum.CONST + + + + +class IfcStructuralPlanarAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPlanarAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_tc1.ifcstructuralloadplanarforce','ifc4x3_tc1.ifcstructuralloadtemperature'] * typeof(self.AppliedLoad))) == 1 + + + + + +class IfcStructuralPointAction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointAction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_tc1.ifcstructuralloadsingleforce','ifc4x3_tc1.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralPointReaction_SuitableLoadType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralPointReaction" + RULE_NAME = "SuitableLoadType" + + @staticmethod + def __call__(self): + + + assert (sizeof(['ifc4x3_tc1.ifcstructuralloadsingleforce','ifc4x3_tc1.ifcstructuralloadsingledisplacement'] * typeof(self.AppliedLoad))) == 1 + + + + + + + + +class IfcStructuralResultGroup_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralResultGroup" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + theorytype = self.TheoryType + + assert (theorytype != IfcAnalysisTheoryTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + +class IfcStructuralSurfaceAction_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + +class IfcStructuralSurfaceAction_ProjectedIsGlobal: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceAction" + RULE_NAME = "ProjectedIsGlobal" + + @staticmethod + def __call__(self): + projectedortrue = self.ProjectedOrTrue + + assert (not exists(projectedortrue)) or ((projectedortrue != projected_length) or (self.GlobalOrLocal == global_coords)) + + + + + + + + +class IfcStructuralSurfaceMember_HasObjectType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceMember" + RULE_NAME = "HasObjectType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceMemberTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStructuralSurfaceReaction_HasPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcStructuralSurfaceReaction" + RULE_NAME = "HasPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) or exists(self.ObjectType) + + + + + + + + +class IfcStyledItem_ApplicableItem: + SCOPE = "entity" + TYPE_NAME = "IfcStyledItem" + RULE_NAME = "ApplicableItem" + + @staticmethod + def __call__(self): + item = self.Item + + assert not 'ifc4x3_tc1.ifcstyleditem' in typeof(item) + + + + + +class IfcStyledRepresentation_OnlyStyledItems: + SCOPE = "entity" + TYPE_NAME = "IfcStyledRepresentation" + RULE_NAME = "OnlyStyledItems" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x3_tc1.ifcstyleditem' in typeof(temp)])) == 0 + + + + + +class IfcSubContractResource_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResource" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcSubContractResourceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSubContractResourceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSubContractResourceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSubContractResourceTypeEnum.USERDEFINED) and exists(self.ResourceType)) + + + + + + + + +def calc_IfcSurface_Dim(self): + + return \ + 3 + + + + +class IfcSurfaceCurve_CurveIs3D: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIs3D" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert curve3d.Dim == 3 + + + + +class IfcSurfaceCurve_CurveIsNotPcurve: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceCurve" + RULE_NAME = "CurveIsNotPcurve" + + @staticmethod + def __call__(self): + curve3d = self.Curve3D + + assert not 'ifc4x3_tc1.ifcpcurve' in typeof(curve3d) + + + + +def calc_IfcSurfaceCurve_BasisSurface(self): + + return \ + IfcGetBasisSurface(self) + + + + + + + +class IfcSurfaceFeature_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceFeature" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSurfaceFeatureTypeEnum.USERDEFINED) or ((predefinedtype == IfcSurfaceFeatureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcSurfaceOfLinearExtrusion_DepthGreaterZero: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceOfLinearExtrusion" + RULE_NAME = "DepthGreaterZero" + + @staticmethod + def __call__(self): + depth = self.Depth + + assert depth > 0. + + + + +def calc_IfcSurfaceOfLinearExtrusion_ExtrusionAxis(self): + extrudeddirection = self.ExtrudedDirection + depth = self.Depth + return \ + IfcVector(Orientation=extrudeddirection, Magnitude=depth) + + + + +def calc_IfcSurfaceOfRevolution_AxisLine(self): + axisposition = self.AxisPosition + return \ + IfcLine(Pnt=axisposition.Location, Dir=IfcVector(Orientation=axisposition.Z, Magnitude=1.0)) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea1: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea1" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + + assert (not exists(surfacereinforcement1)) or (((surfacereinforcement1[1 - 1]) >= 0.) and ((surfacereinforcement1[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement1) == 1) or ((surfacereinforcement1[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea2: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea2" + + @staticmethod + def __call__(self): + surfacereinforcement2 = self.SurfaceReinforcement2 + + assert (not exists(surfacereinforcement2)) or (((surfacereinforcement2[1 - 1]) >= 0.) and ((surfacereinforcement2[2 - 1]) >= 0.) and ((sizeof(surfacereinforcement2) == 1) or ((surfacereinforcement2[1 - 1]) >= 0.))) + + + + +class IfcSurfaceReinforcementArea_NonnegativeArea3: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "NonnegativeArea3" + + @staticmethod + def __call__(self): + shearreinforcement = self.ShearReinforcement + + assert (not exists(shearreinforcement)) or (shearreinforcement >= 0.) + + + + +class IfcSurfaceReinforcementArea_SurfaceAndOrShearAreaSpecified: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceReinforcementArea" + RULE_NAME = "SurfaceAndOrShearAreaSpecified" + + @staticmethod + def __call__(self): + surfacereinforcement1 = self.SurfaceReinforcement1 + surfacereinforcement2 = self.SurfaceReinforcement2 + shearreinforcement = self.ShearReinforcement + + assert exists(surfacereinforcement1) or exists(surfacereinforcement2) or exists(shearreinforcement) + + + + + +class IfcSurfaceStyle_MaxOneExtDefined: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneExtDefined" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_tc1.ifcexternallydefinedsurfacestyle' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneLighting: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneLighting" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_tc1.ifcsurfacestylelighting' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneRefraction: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneRefraction" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_tc1.ifcsurfacestylerefraction' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneShading: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneShading" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_tc1.ifcsurfacestyleshading' in typeof(style)])) <= 1 + + + + +class IfcSurfaceStyle_MaxOneTextures: + SCOPE = "entity" + TYPE_NAME = "IfcSurfaceStyle" + RULE_NAME = "MaxOneTextures" + + @staticmethod + def __call__(self): + + + assert (sizeof([style for style in self.Styles if 'ifc4x3_tc1.ifcsurfacestylewithtextures' in typeof(style)])) <= 1 + + + + + + + + + + + + + + + + + + + + + + + +class IfcSweptAreaSolid_SweptAreaType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptAreaSolid" + RULE_NAME = "SweptAreaType" + + @staticmethod + def __call__(self): + sweptarea = self.SweptArea + + assert sweptarea.ProfileType == IfcProfileTypeEnum.Area + + + + + +class IfcSweptDiskSolid_DirectrixBounded: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixBounded" + + @staticmethod + def __call__(self): + directrix = self.Directrix + startparam = self.StartParam + endparam = self.EndParam + + assert (exists(startparam) and exists(endparam)) or ((sizeof(['ifc4x3_tc1.ifcconic','ifc4x3_tc1.ifcboundedcurve'] * typeof(directrix))) == 1) + + + + +class IfcSweptDiskSolid_DirectrixDim: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "DirectrixDim" + + @staticmethod + def __call__(self): + directrix = self.Directrix + + assert directrix.Dim == 3 + + + + +class IfcSweptDiskSolid_InnerRadiusSize: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolid" + RULE_NAME = "InnerRadiusSize" + + @staticmethod + def __call__(self): + radius = self.Radius + innerradius = self.InnerRadius + + assert (not exists(innerradius)) or (radius > innerradius) + + + + + +class IfcSweptDiskSolidPolygonal_CorrectRadii: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "CorrectRadii" + + @staticmethod + def __call__(self): + filletradius = self.FilletRadius + + assert (not exists(filletradius)) or (filletradius >= self.Radius) + + + + +class IfcSweptDiskSolidPolygonal_DirectrixIsPolyline: + SCOPE = "entity" + TYPE_NAME = "IfcSweptDiskSolidPolygonal" + RULE_NAME = "DirectrixIsPolyline" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_tc1.ifcpolyline' in typeof(self.Directrix)) or (('ifc4x3_tc1.ifcindexedpolycurve' in typeof(self.Directrix)) and (not exists(self.Directrix.Segments))) + + + + + +class IfcSweptSurface_SweptCurveType: + SCOPE = "entity" + TYPE_NAME = "IfcSweptSurface" + RULE_NAME = "SweptCurveType" + + @staticmethod + def __call__(self): + sweptcurve = self.SweptCurve + + assert sweptcurve.ProfileType == IfcProfileTypeEnum.Curve + + + + + +class IfcSwitchingDevice_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSwitchingDevice_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDevice" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcswitchingdevicetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSwitchingDeviceType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSwitchingDeviceType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcSwitchingDeviceTypeEnum.USERDEFINED) or ((predefinedtype == IfcSwitchingDeviceTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + +class IfcSystemFurnitureElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcSystemFurnitureElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcsystemfurnitureelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcSystemFurnitureElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcSystemFurnitureElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcSystemFurnitureElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcSystemFurnitureElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < depth + + + + +class IfcTShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcTShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcTable_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + rows = self.Rows + + assert (sizeof([temp for temp in rows if hiindex(temp.RowCells) != (hiindex(rows[1 - 1].RowCells))])) == 0 + + + + +class IfcTable_WR2: + SCOPE = "entity" + TYPE_NAME = "IfcTable" + RULE_NAME = "WR2" + + @staticmethod + def __call__(self): + numberofheadings = self.NumberOfHeadings + + assert 0 <= numberofheadings <= 1 + + + + +def calc_IfcTable_NumberOfCellsInRow(self): + rows = self.Rows + return \ + hiindex(rows[1 - 1].RowCells) + + + +def calc_IfcTable_NumberOfHeadings(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if temp.IsHeading]) + + + +def calc_IfcTable_NumberOfDataRows(self): + rows = self.Rows + return \ + sizeof([temp for temp in rows if not temp.IsHeading]) + + + + + + + + + + +class IfcTank_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTank_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTank" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifctanktype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTankType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTankType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTankTypeEnum.USERDEFINED) or ((predefinedtype == IfcTankTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTask_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTask_HasName: + SCOPE = "entity" + TYPE_NAME = "IfcTask" + RULE_NAME = "HasName" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + + + + + + + + +class IfcTaskType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTaskType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTaskTypeEnum.USERDEFINED) or ((predefinedtype == IfcTaskTypeEnum.USERDEFINED) and exists(self.ProcessType)) + + + + + +class IfcTelecomAddress_MinimumDataProvided: + SCOPE = "entity" + TYPE_NAME = "IfcTelecomAddress" + RULE_NAME = "MinimumDataProvided" + + @staticmethod + def __call__(self): + telephonenumbers = self.TelephoneNumbers + facsimilenumbers = self.FacsimileNumbers + pagernumber = self.PagerNumber + electronicmailaddresses = self.ElectronicMailAddresses + wwwhomepageurl = self.WWWHomePageURL + messagingids = self.MessagingIDs + + assert exists(telephonenumbers) or exists(facsimilenumbers) or exists(pagernumber) or exists(electronicmailaddresses) or exists(wwwhomepageurl) or exists(messagingids) + + + + + +class IfcTendon_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendon_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendon" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifctendontype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchor_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonAnchor_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchor" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifctendonanchortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonAnchorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonAnchorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonAnchorTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonAnchorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonConduit_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTendonConduit_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduit" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifctendonconduittype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTendonConduitType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonConduitType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonConduitTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonConduitTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTendonType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTendonType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTendonTypeEnum.USERDEFINED) or ((predefinedtype == IfcTendonTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +def calc_IfcTessellatedFaceSet_Dim(self): + + return \ + 3 + + + + + + + + + + +class IfcTextLiteralWithExtent_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcTextLiteralWithExtent" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + extent = self.Extent + + assert not 'ifc4x3_tc1.ifcplanarbox' in typeof(extent) + + + + + + + + +class IfcTextStyleFontModel_MeasureOfFontSize: + SCOPE = "entity" + TYPE_NAME = "IfcTextStyleFontModel" + RULE_NAME = "MeasureOfFontSize" + + @staticmethod + def __call__(self): + + + assert ('ifc4x3_tc1.ifclengthmeasure' in typeof(self.FontSize)) and (self.FontSize > 0.) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class IfcTopologyRepresentation_WR21: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR21" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in self.Items if not 'ifc4x3_tc1.ifctopologicalrepresentationitem' in typeof(temp)])) == 0 + + + + +class IfcTopologyRepresentation_WR22: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR22" + + @staticmethod + def __call__(self): + + + assert exists(self.RepresentationType) + + + + +class IfcTopologyRepresentation_WR23: + SCOPE = "entity" + TYPE_NAME = "IfcTopologyRepresentation" + RULE_NAME = "WR23" + + @staticmethod + def __call__(self): + + + assert IfcTopologyRepresentationTypes(self.RepresentationType,self.Items) + + + + + +class IfcToroidalSurface_MajorLargerMinor: + SCOPE = "entity" + TYPE_NAME = "IfcToroidalSurface" + RULE_NAME = "MajorLargerMinor" + + @staticmethod + def __call__(self): + majorradius = self.MajorRadius + minorradius = self.MinorRadius + + assert minorradius < majorradius + + + + + +class IfcTrackElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTrackElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTrackElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTrackElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifctrackelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTrackElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTrackElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTrackElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTrackElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTransformer_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransformer_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransformer" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifctransformertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransformerType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransformerType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransformerTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransformerTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTransportElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTransportElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransportElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTransportElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifctransportelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTransportElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTransportElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTransportElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcTransportElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +def calc_IfcTriangulatedFaceSet_NumberOfTriangles(self): + coordindex = self.CoordIndex + return \ + sizeof(coordindex) + + + + +class IfcTriangulatedIrregularNetwork_NotClosed: + SCOPE = "entity" + TYPE_NAME = "IfcTriangulatedIrregularNetwork" + RULE_NAME = "NotClosed" + + @staticmethod + def __call__(self): + + + assert self.Closed == False + + + + + +class IfcTrimmedCurve_NoTrimOfBoundedCurves: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "NoTrimOfBoundedCurves" + + @staticmethod + def __call__(self): + basiscurve = self.BasisCurve + + assert not 'ifc4x3_tc1.ifcboundedcurve' in typeof(basiscurve) + + + + +class IfcTrimmedCurve_Trim1ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim1ValuesConsistent" + + @staticmethod + def __call__(self): + trim1 = self.Trim1 + + assert (hiindex(trim1) == 1) or ((typeof(trim1[1 - 1])) != (typeof(trim1[2 - 1]))) + + + + +class IfcTrimmedCurve_Trim2ValuesConsistent: + SCOPE = "entity" + TYPE_NAME = "IfcTrimmedCurve" + RULE_NAME = "Trim2ValuesConsistent" + + @staticmethod + def __call__(self): + trim2 = self.Trim2 + + assert (hiindex(trim2) == 1) or ((typeof(trim2[1 - 1])) != (typeof(trim2[2 - 1]))) + + + + + +class IfcTubeBundle_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcTubeBundle_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundle" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifctubebundletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcTubeBundleType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcTubeBundleType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcTubeBundleTypeEnum.USERDEFINED) or ((predefinedtype == IfcTubeBundleTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcTypeObject_NameRequired: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "NameRequired" + + @staticmethod + def __call__(self): + + + assert exists(self.Name) + + + + +class IfcTypeObject_UniquePropertySetNames: + SCOPE = "entity" + TYPE_NAME = "IfcTypeObject" + RULE_NAME = "UniquePropertySetNames" + + @staticmethod + def __call__(self): + haspropertysets = self.HasPropertySets + + assert (not exists(haspropertysets)) or IfcUniquePropertySetNames(haspropertysets) + + + + + + + + +class IfcTypeProduct_ApplicableOccurrence: + SCOPE = "entity" + TYPE_NAME = "IfcTypeProduct" + RULE_NAME = "ApplicableOccurrence" + + @staticmethod + def __call__(self): + + + assert (not exists(lambda: self.Types[1 - 1])) or ((sizeof([temp for temp in self.Types[1 - 1].RelatedObjects if not 'ifc4x3_tc1.ifcproduct' in typeof(temp)])) == 0) + + + + + + + + +class IfcUShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + +class IfcUShapeProfileDef_ValidWebThickness: + SCOPE = "entity" + TYPE_NAME = "IfcUShapeProfileDef" + RULE_NAME = "ValidWebThickness" + + @staticmethod + def __call__(self): + flangewidth = self.FlangeWidth + webthickness = self.WebThickness + + assert webthickness < flangewidth + + + + + +class IfcUnitAssignment_WR01: + SCOPE = "entity" + TYPE_NAME = "IfcUnitAssignment" + RULE_NAME = "WR01" + + @staticmethod + def __call__(self): + units = self.Units + + assert IfcCorrectUnitAssignment(units) + + + + + +class IfcUnitaryControlElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryControlElement_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElement" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcunitarycontrolelementtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryControlElementType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryControlElementType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryControlElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryControlElementTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcUnitaryEquipment_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcUnitaryEquipment_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipment" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcunitaryequipmenttype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcUnitaryEquipmentType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcUnitaryEquipmentType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcUnitaryEquipmentTypeEnum.USERDEFINED) or ((predefinedtype == IfcUnitaryEquipmentTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcValve_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcValve_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcValve" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcvalvetype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcValveType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcValveType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcValveTypeEnum.USERDEFINED) or ((predefinedtype == IfcValveTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVector_MagGreaterOrEqualZero: + SCOPE = "entity" + TYPE_NAME = "IfcVector" + RULE_NAME = "MagGreaterOrEqualZero" + + @staticmethod + def __call__(self): + magnitude = self.Magnitude + + assert magnitude >= 0.0 + + + + +def calc_IfcVector_Dim(self): + orientation = self.Orientation + return \ + orientation.Dim + + + + +class IfcVehicle_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVehicle" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVehicleTypeEnum.USERDEFINED) or ((predefinedtype == IfcVehicleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVehicle_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVehicle" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcvehicletype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVehicleType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVehicleType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVehicleTypeEnum.USERDEFINED) or ((predefinedtype == IfcVehicleTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + + + + + + + + + + +class IfcVibrationDamper_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationDamper_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamper" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcvibrationdampertype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationDamperType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationDamperType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationDamperTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationDamperTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVibrationIsolator_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcVibrationIsolator_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolator" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcvibrationisolatortype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcVibrationIsolatorType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVibrationIsolatorType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcVibrationIsolatorTypeEnum.USERDEFINED) or ((predefinedtype == IfcVibrationIsolatorTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcVirtualElement_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVirtualElement" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVirtualElementTypeEnum.USERDEFINED) or ((predefinedtype == IfcVirtualElementTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcVoidingFeature_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcVoidingFeature" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcVoidingFeatureTypeEnum.USERDEFINED) or ((predefinedtype == IfcVoidingFeatureTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcWall_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWall_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWall" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcwalltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWallStandardCase_HasMaterialLayerSetUsage: + SCOPE = "entity" + TYPE_NAME = "IfcWallStandardCase" + RULE_NAME = "HasMaterialLayerSetUsage" + + @staticmethod + def __call__(self): + + + assert (sizeof([temp for temp in usedin(self,'ifc4x3_tc1.ifcrelassociates.relatedobjects') if ('ifc4x3_tc1.ifcrelassociatesmaterial' in typeof(temp)) and ('ifc4x3_tc1.ifcmateriallayersetusage' in typeof(temp.RelatingMaterial))])) == 1 + + + + + +class IfcWallType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWallType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWallTypeEnum.USERDEFINED) or ((predefinedtype == IfcWallTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWasteTerminal_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWasteTerminal_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminal" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcwasteterminaltype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWasteTerminalType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWasteTerminalType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWasteTerminalTypeEnum.USERDEFINED) or ((predefinedtype == IfcWasteTerminalTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWindow_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWindowTypeEnum.USERDEFINED) or ((predefinedtype == IfcWindowTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + +class IfcWindow_CorrectTypeAssigned: + SCOPE = "entity" + TYPE_NAME = "IfcWindow" + RULE_NAME = "CorrectTypeAssigned" + + @staticmethod + def __call__(self): + istypedby = self.IsTypedBy + + assert (sizeof(istypedby) == 0) or ('ifc4x3_tc1.ifcwindowtype' in (typeof(self.IsTypedBy[1 - 1].RelatingType))) + + + + + +class IfcWindowLiningProperties_WR31: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR31" + + @staticmethod + def __call__(self): + liningdepth = self.LiningDepth + liningthickness = self.LiningThickness + + assert not exists(liningdepth) and (not exists(liningthickness)) + + + + +class IfcWindowLiningProperties_WR32: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR32" + + @staticmethod + def __call__(self): + firsttransomoffset = self.FirstTransomOffset + secondtransomoffset = self.SecondTransomOffset + + assert not (not exists(firsttransomoffset)) and exists(secondtransomoffset) + + + + +class IfcWindowLiningProperties_WR33: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR33" + + @staticmethod + def __call__(self): + firstmullionoffset = self.FirstMullionOffset + secondmullionoffset = self.SecondMullionOffset + + assert not (not exists(firstmullionoffset)) and exists(secondmullionoffset) + + + + +class IfcWindowLiningProperties_WR34: + SCOPE = "entity" + TYPE_NAME = "IfcWindowLiningProperties" + RULE_NAME = "WR34" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and ('ifc4x3_tc1.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) + + + + + +class IfcWindowPanelProperties_ApplicableToType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowPanelProperties" + RULE_NAME = "ApplicableToType" + + @staticmethod + def __call__(self): + + + assert (exists(lambda: self.DefinesType[1 - 1])) and ('ifc4x3_tc1.ifcwindowtype' in (typeof(self.DefinesType[1 - 1]))) + + + + + +class IfcWindowType_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWindowType" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (predefinedtype != IfcWindowTypeEnum.USERDEFINED) or ((predefinedtype == IfcWindowTypeEnum.USERDEFINED) and exists(self.ElementType)) + + + + + +class IfcWorkCalendar_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkCalendar" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkCalendarTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkCalendarTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcWorkPlan_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkPlan" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkPlanTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkPlanTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + +class IfcWorkSchedule_CorrectPredefinedType: + SCOPE = "entity" + TYPE_NAME = "IfcWorkSchedule" + RULE_NAME = "CorrectPredefinedType" + + @staticmethod + def __call__(self): + predefinedtype = self.PredefinedType + + assert (not exists(predefinedtype)) or (predefinedtype != IfcWorkScheduleTypeEnum.USERDEFINED) or ((predefinedtype == IfcWorkScheduleTypeEnum.USERDEFINED) and exists(self.ObjectType)) + + + + + + + + +class IfcZShapeProfileDef_ValidFlangeThickness: + SCOPE = "entity" + TYPE_NAME = "IfcZShapeProfileDef" + RULE_NAME = "ValidFlangeThickness" + + @staticmethod + def __call__(self): + depth = self.Depth + flangethickness = self.FlangeThickness + + assert flangethickness < (depth / 2.) + + + + + +class IfcZone_WR1: + SCOPE = "entity" + TYPE_NAME = "IfcZone" + RULE_NAME = "WR1" + + @staticmethod + def __call__(self): + + + assert (sizeof(self.IsGroupedBy) == 0) or ((sizeof([temp for temp in self.IsGroupedBy[1 - 1].RelatedObjects if not ('ifc4x3_tc1.ifczone' in typeof(temp)) or ('ifc4x3_tc1.ifcspace' in typeof(temp)) or ('ifc4x3_tc1.ifcspatialzone' in typeof(temp))])) == 0) + + + + + +class IfcRepresentationContextSameWCS: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcGeometricRepresentationContext = file.by_type("IfcGeometricRepresentationContext") + isdifferent = False + if sizeof(IfcGeometricRepresentationContext) > 1: + for i in range(2, hiindex(IfcGeometricRepresentationContext) + 1): + if (IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem) != (IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem): + isdifferent = (not IfcSameValidPrecision(IfcGeometricRepresentationContext[1 - 1].Precision,IfcGeometricRepresentationContext[i - 1].Precision)) or (not IfcSameAxis2Placement(IfcGeometricRepresentationContext[1 - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[i - 1].WorldCoordinateSystem,IfcGeometricRepresentationContext[1 - 1].Precision)) + if isdifferent == True: + break + + assert isdifferent == False + + + + + +class IfcSingleProjectInstance: + SCOPE = "file" + + @staticmethod + def __call__(file): + IfcProject = file.by_type("IfcProject") + + + + assert sizeof(IfcProject) <= 1 + + + + +def IfcAssociatedSurface(arg): + + surf = arg.BasisSurface + return surf + + +def IfcBaseAxis(dim, axis1, axis2, axis3): + + + + if dim == 3: + d1 = nvl(IfcNormalise(axis3),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,axis1) + u = [d2,IfcSecondProjAxis(d1,d2,axis2),d1] + else: + if exists(axis1): + d1 = IfcNormalise(axis1) + u = [d1,IfcOrthogonalComplement(d1)] + if exists(axis2): + factor = IfcDotProduct(axis2,u[2 - 1]) + if factor < 0.0: + u[2 - 1].DirectionRatios[1 - 1] = -u[2 - 1].DirectionRatios[1 - 1] + u[2 - 1].DirectionRatios[2 - 1] = -u[2 - 1].DirectionRatios[2 - 1] + else: + if exists(axis2): + d1 = IfcNormalise(axis2) + u = [IfcOrthogonalComplement(d1),d1] + u[1 - 1].DirectionRatios[1 - 1] = -u[1 - 1].DirectionRatios[1 - 1] + u[1 - 1].DirectionRatios[2 - 1] = -u[1 - 1].DirectionRatios[2 - 1] + else: + u = [IfcDirection(DirectionRatios=[1.0,0.0]),IfcDirection(DirectionRatios=[0.0,1.0])] + return u + + +def IfcBooleanChoose(b, choice1, choice2): + + if b: + return choice1 + else: + return choice2 + + +def IfcBuild2Axes(refdirection): + d = nvl(IfcNormalise(refdirection),IfcDirection(DirectionRatios=[1.0,0.0])) + return [d,IfcOrthogonalComplement(d)] + + +def IfcBuildAxes(axis, refdirection): + + d1 = nvl(IfcNormalise(axis),IfcDirection(DirectionRatios=[0.0,0.0,1.0])) + d2 = IfcFirstProjAxis(d1,refdirection) + return [d2,IfcNormalise(IfcCrossProduct(d1,d2)).Orientation,d1] + + +def IfcConsecutiveSegments(segments): + result = True + for i in range(1, hiindex(segments) - 1 + 1): + if (segments[i - 1][hiindex(segments[i - 1]) - 1]) != (segments[i - 1][1 - 1]): + result = False + break + return result + + +def IfcConstraintsParamBSpline(degree, upknots, upcp, knotmult, knots): + result = True + + sum = knotmult[1 - 1] + for i in range(2, upknots + 1): + sum = sum + (knotmult[i - 1]) + if (degree < 1) or (upknots < 2) or (upcp < degree) or (sum != (degree + upcp + 2)): + result = False + return result + k = knotmult[1 - 1] + if (k < 1) or (k > (degree + 1)): + result = False + return result + for i in range(2, upknots + 1): + if ((knotmult[i - 1]) < 1) or ((knots[i - 1]) <= (knots[i - 1])): + result = False + return result + k = knotmult[i - 1] + if (i < upknots) and (k > degree): + result = False + return result + if (i == upknots) and (k > (degree + 1)): + result = False + return result + return result + + +def IfcConvertDirectionInto2D(direction): + direction2d = IfcDirection(DirectionRatios=[0.,1.]) + temp = list(direction2d.DirectionRatios) + temp[1 - 1] = direction.DirectionRatios[1 - 1] + direction2d.DirectionRatios = temp + temp = list(direction2d.DirectionRatios) + temp[2 - 1] = direction.DirectionRatios[2 - 1] + direction2d.DirectionRatios = temp + return direction2d + + +def IfcCorrectDimensions(m, dim): + + if m == lengthunit: + if dim == IfcDimensionalExponents(1,0,0,0,0,0,0): + return True + else: + return False + elif m == massunit: + if dim == IfcDimensionalExponents(0,1,0,0,0,0,0): + return True + else: + return False + elif m == timeunit: + if dim == IfcDimensionalExponents(0,0,1,0,0,0,0): + return True + else: + return False + elif m == electriccurrentunit: + if dim == IfcDimensionalExponents(0,0,0,1,0,0,0): + return True + else: + return False + elif m == thermodynamictemperatureunit: + if dim == IfcDimensionalExponents(0,0,0,0,1,0,0): + return True + else: + return False + elif m == amountofsubstanceunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,1,0): + return True + else: + return False + elif m == luminousintensityunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == planeangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == solidangleunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,0): + return True + else: + return False + elif m == areaunit: + if dim == IfcDimensionalExponents(2,0,0,0,0,0,0): + return True + else: + return False + elif m == volumeunit: + if dim == IfcDimensionalExponents(3,0,0,0,0,0,0): + return True + else: + return False + elif m == absorbeddoseunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == radioactivityunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == electriccapacitanceunit: + if dim == IfcDimensionalExponents(-2,-1,4,2,0,0,0): + return True + else: + return False + elif m == doseequivalentunit: + if dim == IfcDimensionalExponents(2,0,-2,0,0,0,0): + return True + else: + return False + elif m == electricchargeunit: + if dim == IfcDimensionalExponents(0,0,1,1,0,0,0): + return True + else: + return False + elif m == electricconductanceunit: + if dim == IfcDimensionalExponents(-2,-1,3,2,0,0,0): + return True + else: + return False + elif m == electricvoltageunit: + if dim == IfcDimensionalExponents(2,1,-3,-1,0,0,0): + return True + else: + return False + elif m == electricresistanceunit: + if dim == IfcDimensionalExponents(2,1,-3,-2,0,0,0): + return True + else: + return False + elif m == energyunit: + if dim == IfcDimensionalExponents(2,1,-2,0,0,0,0): + return True + else: + return False + elif m == forceunit: + if dim == IfcDimensionalExponents(1,1,-2,0,0,0,0): + return True + else: + return False + elif m == frequencyunit: + if dim == IfcDimensionalExponents(0,0,-1,0,0,0,0): + return True + else: + return False + elif m == inductanceunit: + if dim == IfcDimensionalExponents(2,1,-2,-2,0,0,0): + return True + else: + return False + elif m == illuminanceunit: + if dim == IfcDimensionalExponents(-2,0,0,0,0,0,1): + return True + else: + return False + elif m == luminousfluxunit: + if dim == IfcDimensionalExponents(0,0,0,0,0,0,1): + return True + else: + return False + elif m == magneticfluxunit: + if dim == IfcDimensionalExponents(2,1,-2,-1,0,0,0): + return True + else: + return False + elif m == magneticfluxdensityunit: + if dim == IfcDimensionalExponents(0,1,-2,-1,0,0,0): + return True + else: + return False + elif m == powerunit: + if dim == IfcDimensionalExponents(2,1,-3,0,0,0,0): + return True + else: + return False + elif m == pressureunit: + if dim == IfcDimensionalExponents(-1,1,-2,0,0,0,0): + return True + else: + return False + else: + return unknown + + +def IfcCorrectFillAreaStyle(styles): + hatching = 0 + tiles = 0 + colour = 0 + external = 0 + external = sizeof([style for style in styles if 'ifc4x3_tc1.ifcexternallydefinedhatchstyle' in typeof(style)]) + hatching = sizeof([style for style in styles if 'ifc4x3_tc1.ifcfillareastylehatching' in typeof(style)]) + tiles = sizeof([style for style in styles if 'ifc4x3_tc1.ifcfillareastyletiles' in typeof(style)]) + colour = sizeof([style for style in styles if 'ifc4x3_tc1.ifccolour' in typeof(style)]) + if external > 1: + return False + if (external == 1) and ((hatching > 0) or (tiles > 0) or (colour > 0)): + return False + if colour > 1: + return False + if (hatching > 0) and (tiles > 0): + return False + return True + + +def IfcCorrectLocalPlacement(axisplacement, relplacement): + + if exists(relplacement): + if 'ifc4x3_tc1.ifcgridplacement' in typeof(relplacement): + return None + if 'ifc4x3_tc1.ifclocalplacement' in typeof(relplacement): + if 'ifc4x3_tc1.ifcaxis2placement2d' in typeof(axisplacement): + return True + if 'ifc4x3_tc1.ifcaxis2placement3d' in typeof(axisplacement): + if relplacement.RelativePlacement.Dim == 3: + return True + else: + return False + return True + return None + + +def IfcCorrectUnitAssignment(units): + namedunitnumber = 0 + derivedunitnumber = 0 + monetaryunitnumber = 0 + namedunitnames = express_set([]) + derivedunitnames = express_set([]) + namedunitnumber = sizeof([temp for temp in units if ('ifc4x3_tc1.ifcnamedunit' in typeof(temp)) and (not temp.UnitType == IfcUnitEnum.USERDEFINED)]) + derivedunitnumber = sizeof([temp for temp in units if ('ifc4x3_tc1.ifcderivedunit' in typeof(temp)) and (not temp.UnitType == IfcDerivedUnitEnum.USERDEFINED)]) + monetaryunitnumber = sizeof([temp for temp in units if 'ifc4x3_tc1.ifcmonetaryunit' in typeof(temp)]) + for i in range(1, sizeof(units) + 1): + if ('ifc4x3_tc1.ifcnamedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcUnitEnum.USERDEFINED): + namedunitnames = namedunitnames + (units[i - 1].UnitType) + if ('ifc4x3_tc1.ifcderivedunit' in (typeof(units[i - 1]))) and (not (units[i - 1].UnitType) == IfcDerivedUnitEnum.USERDEFINED): + derivedunitnames = derivedunitnames + (units[i - 1].UnitType) + return (sizeof(namedunitnames) == namedunitnumber) and (sizeof(derivedunitnames) == derivedunitnumber) and (monetaryunitnumber <= 1) + + +def IfcCrossProduct(arg1, arg2): + + + + + if ((not exists(arg1)) or (arg1.Dim == 2)) or ((not exists(arg2)) or (arg2.Dim == 2)): + return None + else: + v1 = IfcNormalise(arg1).DirectionRatios + v2 = IfcNormalise(arg2).DirectionRatios + res = IfcDirection(DirectionRatios=[((v1[2 - 1]) * (v2[3 - 1])) - ((v1[3 - 1]) * (v2[2 - 1])),((v1[3 - 1]) * (v2[1 - 1])) - ((v1[1 - 1]) * (v2[3 - 1])),((v1[1 - 1]) * (v2[2 - 1])) - ((v1[2 - 1]) * (v2[1 - 1]))]) + mag = 0.0 + for i in range(1, 3 + 1): + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=arg1, Magnitude=0.0) + return result + + +def IfcCurveDim(curve): + + if 'ifc4x3_tc1.ifcline' in typeof(curve): + return curve.Pnt.Dim + if 'ifc4x3_tc1.ifcconic' in typeof(curve): + return curve.Position.Dim + if 'ifc4x3_tc1.ifcpolyline' in typeof(curve): + return curve.Points[1 - 1].Dim + if 'ifc4x3_tc1.ifctrimmedcurve' in typeof(curve): + return IfcCurveDim(curve.BasisCurve) + if 'ifc4x3_tc1.ifcgradientcurve' in typeof(curve): + return 3 + if 'ifc4x3_tc1.ifcsegmentedreferencecurve' in typeof(curve): + return 3 + if 'ifc4x3_tc1.ifccompositecurve' in typeof(curve): + return curve.Segments[1 - 1].Dim + if 'ifc4x3_tc1.ifcbsplinecurve' in typeof(curve): + return curve.ControlPointsList[1 - 1].Dim + if 'ifc4x3_tc1.ifcoffsetcurve2d' in typeof(curve): + return 2 + if 'ifc4x3_tc1.ifcoffsetcurve3d' in typeof(curve): + return 3 + if 'ifc4x3_tc1.ifcoffsetcurvebydistances' in typeof(curve): + return 3 + if 'ifc4x3_tc1.ifccurvesegment2d' in typeof(curve): + return 2 + if 'ifc4x3_tc1.ifcpolynomialcurve' in typeof(curve): + if (not exists(curve.CoefficientsZ)) and (curve.Position.Dim == 2): + return 2 + return 3 + if 'ifc4x3_tc1.ifcpcurve' in typeof(curve): + return 3 + if 'ifc4x3_tc1.ifcindexedpolycurve' in typeof(curve): + return curve.Points.Dim + return None + + +def IfcCurveWeightsPositive(b): + result = True + for i in range(0, b.UpperIndexOnControlPoints + 1): + if (b.Weights[i - 1]) <= 0.0: + result = False + return result + return result + + +def IfcDeriveDimensionalExponents(unitelements): + result = IfcDimensionalExponents(0,0,0,0,0,0,0) + for i in range(loindex(unitelements), hiindex(unitelements) + 1): + result.LengthExponent = result.LengthExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LengthExponent)) + result.MassExponent = result.MassExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.MassExponent)) + result.TimeExponent = result.TimeExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.TimeExponent)) + result.ElectricCurrentExponent = result.ElectricCurrentExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ElectricCurrentExponent)) + result.ThermodynamicTemperatureExponent = result.ThermodynamicTemperatureExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.ThermodynamicTemperatureExponent)) + result.AmountOfSubstanceExponent = result.AmountOfSubstanceExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.AmountOfSubstanceExponent)) + result.LuminousIntensityExponent = result.LuminousIntensityExponent + ((unitelements[i - 1].Exponent) * (unitelements[i - 1].Unit.Dimensions.LuminousIntensityExponent)) + return result + + +def IfcDimensionsForSIUnit(n): + + if n == metre: + return IfcDimensionalExponents(1,0,0,0,0,0,0) + elif n == square_metre: + return IfcDimensionalExponents(2,0,0,0,0,0,0) + elif n == cubic_metre: + return IfcDimensionalExponents(3,0,0,0,0,0,0) + elif n == gram: + return IfcDimensionalExponents(0,1,0,0,0,0,0) + elif n == second: + return IfcDimensionalExponents(0,0,1,0,0,0,0) + elif n == ampere: + return IfcDimensionalExponents(0,0,0,1,0,0,0) + elif n == kelvin: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == mole: + return IfcDimensionalExponents(0,0,0,0,0,1,0) + elif n == candela: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == radian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == steradian: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + elif n == hertz: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == newton: + return IfcDimensionalExponents(1,1,-2,0,0,0,0) + elif n == pascal: + return IfcDimensionalExponents(-1,1,-2,0,0,0,0) + elif n == joule: + return IfcDimensionalExponents(2,1,-2,0,0,0,0) + elif n == watt: + return IfcDimensionalExponents(2,1,-3,0,0,0,0) + elif n == coulomb: + return IfcDimensionalExponents(0,0,1,1,0,0,0) + elif n == volt: + return IfcDimensionalExponents(2,1,-3,-1,0,0,0) + elif n == farad: + return IfcDimensionalExponents(-2,-1,4,2,0,0,0) + elif n == ohm: + return IfcDimensionalExponents(2,1,-3,-2,0,0,0) + elif n == siemens: + return IfcDimensionalExponents(-2,-1,3,2,0,0,0) + elif n == weber: + return IfcDimensionalExponents(2,1,-2,-1,0,0,0) + elif n == tesla: + return IfcDimensionalExponents(0,1,-2,-1,0,0,0) + elif n == henry: + return IfcDimensionalExponents(2,1,-2,-2,0,0,0) + elif n == degree_celsius: + return IfcDimensionalExponents(0,0,0,0,1,0,0) + elif n == lumen: + return IfcDimensionalExponents(0,0,0,0,0,0,1) + elif n == lux: + return IfcDimensionalExponents(-2,0,0,0,0,0,1) + elif n == becquerel: + return IfcDimensionalExponents(0,0,-1,0,0,0,0) + elif n == gray: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + elif n == sievert: + return IfcDimensionalExponents(2,0,-2,0,0,0,0) + else: + return IfcDimensionalExponents(0,0,0,0,0,0,0) + + +def IfcDotProduct(arg1, arg2): + + + + if (not exists(arg1)) or (not exists(arg2)): + scalar = None + else: + if arg1.Dim != arg2.Dim: + scalar = None + else: + vec1 = IfcNormalise(arg1) + vec2 = IfcNormalise(arg2) + ndim = arg1.Dim + scalar = 0.0 + for i in range(1, ndim + 1): + scalar = scalar + ((vec1.DirectionRatios[i - 1]) * (vec2.DirectionRatios[i - 1])) + return scalar + + +def IfcFirstProjAxis(zaxis, arg): + + + + + if not exists(zaxis): + return None + else: + z = IfcNormalise(zaxis) + if not exists(arg): + if z.DirectionRatios != [1.0,0.0,0.0]: + v = IfcDirection(DirectionRatios=[1.0,0.0,0.0]) + else: + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + if arg.Dim != 3: + return None + if IfcCrossProduct(arg,z).Magnitude == 0.0: + return None + else: + v = IfcNormalise(arg) + xvec = IfcScalarTimesVector(IfcDotProduct(v,z),z) + xaxis = IfcVectorDifference(v,xvec).Orientation + xaxis = IfcNormalise(xaxis) + return xaxis + + +def IfcGetBasisSurface(c): + + + surfs = [] + if 'ifc4x3_tc1.ifcpcurve' in typeof(c): + surfs = [c.BasisSurface] + else: + if 'ifc4x3_tc1.ifcsurfacecurve' in typeof(c): + n = sizeof(c.AssociatedGeometry) + for i in range(1, n + 1): + surfs = surfs + (IfcAssociatedSurface(c.AssociatedGeometry[i - 1])) + if 'ifc4x3_tc1.ifccompositecurveonsurface' in typeof(c): + n = sizeof(c.Segments) + if 'ifc4x3_tc1.ifccurvesegment' in (typeof(c.Segments[1 - 1])): + surfs = IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve) + if 'ifc4x3_tc1.ifccompositecurvesegment' in (typeof(c.Segments[1 - 1])): + surfs = IfcGetBasisSurface(c.Segments[1 - 1].ParentCurve) + if n > 1: + for i in range(2, n + 1): + if 'ifc4x3_tc1.ifccurvesegment' in (typeof(c.Segments[i - 1])): + surfs = surfs * (IfcGetBasisSurface(c.Segments[i - 1].ParentCurve)) + if 'ifc4x3_tc1.ifccompositecurvesegment' in (typeof(c.Segments[i - 1])): + surfs = surfs * (IfcGetBasisSurface(c.Segments[i - 1].ParentCurve)) + return surfs + + +def IfcListToArray(lis, low, u): + + + n = sizeof(lis) + if n != (u - low + 1): + return None + else: + res = ([lis[1 - 1]] * n) + for i in range(2, n + 1): + temp = list(res) + temp[low - 1] = lis[i - 1] + res = temp + return res + + +def IfcLoopHeadToTail(aloop): + + p = True + n = sizeof(aloop.EdgeList) + for i in range(2, n + 1): + p = p and ((aloop.EdgeList[i - 1].EdgeEnd) == (aloop.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcMakeArrayOfArray(lis, low1, u1, low2, u2): + + if (u1 - low1 + 1) != sizeof(lis): + return None + if (u2 - low2 + 1) != (sizeof(lis[1 - 1])): + return None + res = ([IfcListToArray(lis[1 - 1],low2,u2)] * u1 - low1 + 1) + for i in range(2, hiindex(lis) + 1): + if (u2 - low2 + 1) != (sizeof(lis[i - 1])): + return None + temp = list(res) + temp[low1 - 1] = IfcListToArray(lis[i - 1],low2,u2) + res = temp + return res + + +def IfcMlsTotalThickness(layerset): + max = layerset.MaterialLayers[1 - 1].LayerThickness + if sizeof(layerset.MaterialLayers) > 1: + for i in range(2, hiindex(layerset.MaterialLayers) + 1): + max = max + (layerset.MaterialLayers[i - 1].LayerThickness) + return max + + +def IfcNormalise(arg): + + v = IfcDirection(DirectionRatios=[1.,0.]) + vec = IfcVector(Orientation=IfcDirection(DirectionRatios=[1.,0.]), Magnitude=1.) + + result = v + if not exists(arg): + return None + else: + if 'ifc4x3_tc1.ifcvector' in typeof(arg): + ndim = arg.Dim + v.DirectionRatios = arg.Orientation.DirectionRatios + vec.Magnitude = arg.Magnitude + vec.Orientation = v + if arg.Magnitude == 0.0: + return None + else: + vec.Magnitude = 1.0 + else: + ndim = arg.Dim + v.DirectionRatios = arg.DirectionRatios + mag = 0.0 + for i in range(1, ndim + 1): + mag = mag + ((v.DirectionRatios[i - 1]) * (v.DirectionRatios[i - 1])) + if mag > 0.0: + mag = sqrt(mag) + for i in range(1, ndim + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = (v.DirectionRatios[i - 1]) / mag + v.DirectionRatios = temp + if 'ifc4x3_tc1.ifcvector' in typeof(arg): + vec.Orientation = v + result = vec + else: + result = v + else: + return None + return result + + +def IfcOrthogonalComplement(vec): + + if (not exists(vec)) or (vec.Dim != 2): + return None + else: + result = IfcDirection(DirectionRatios=[-vec.DirectionRatios[2 - 1],vec.DirectionRatios[1 - 1]]) + return result + + +def IfcPathHeadToTail(apath): + n = 0 + p = unknown + n = sizeof(apath.EdgeList) + for i in range(2, n + 1): + p = p and ((apath.EdgeList[i - 1].EdgeEnd) == (apath.EdgeList[i - 1].EdgeStart)) + return p + + +def IfcPointDim(point): + + if 'ifc4x3_tc1.ifccartesianpoint' in typeof(point): + return hiindex(point.Coordinates) + if 'ifc4x3_tc1.ifcpointbydistanceexpression' in typeof(point): + return point.BasisCurve.Dim + if 'ifc4x3_tc1.ifcpointoncurve' in typeof(point): + return point.BasisCurve.Dim + if 'ifc4x3_tc1.ifcpointonsurface' in typeof(point): + return point.BasisSurface.Dim + return None + + +def IfcPointListDim(pointlist): + + if 'ifc4x3_tc1.ifccartesianpointlist2d' in typeof(pointlist): + return 2 + if 'ifc4x3_tc1.ifccartesianpointlist3d' in typeof(pointlist): + return 3 + return None + + +def IfcSameAxis2Placement(ap1, ap2, epsilon): + + return (IfcSameDirection(ap1.P[1 - 1],ap2.P[1 - 1],epsilon)) and (IfcSameDirection(ap1.P[2 - 1],ap2.P[2 - 1],epsilon)) and IfcSameCartesianPoint(ap1.Location,ap2.Location,epsilon) + + +def IfcSameCartesianPoint(cp1, cp2, epsilon): + cp1x = cp1.Coordinates[1 - 1] + cp1y = cp1.Coordinates[2 - 1] + cp1z = 0 + cp2x = cp2.Coordinates[1 - 1] + cp2y = cp2.Coordinates[2 - 1] + cp2z = 0 + if sizeof(cp1.Coordinates) > 2: + cp1z = cp1.Coordinates[3 - 1] + if sizeof(cp2.Coordinates) > 2: + cp2z = cp2.Coordinates[3 - 1] + return IfcSameValue(cp1x,cp2x,epsilon) and IfcSameValue(cp1y,cp2y,epsilon) and IfcSameValue(cp1z,cp2z,epsilon) + + +def IfcSameDirection(dir1, dir2, epsilon): + dir1x = dir1.DirectionRatios[1 - 1] + dir1y = dir1.DirectionRatios[2 - 1] + dir1z = 0 + dir2x = dir2.DirectionRatios[1 - 1] + dir2y = dir2.DirectionRatios[2 - 1] + dir2z = 0 + if sizeof(dir1.DirectionRatios) > 2: + dir1z = dir1.DirectionRatios[3 - 1] + if sizeof(dir2.DirectionRatios) > 2: + dir2z = dir2.DirectionRatios[3 - 1] + return IfcSameValue(dir1x,dir2x,epsilon) and IfcSameValue(dir1y,dir2y,epsilon) and IfcSameValue(dir1z,dir2z,epsilon) + + +def IfcSameValidPrecision(epsilon1, epsilon2): + + defaulteps = 0.000001 + derivationofeps = 1.001 + uppereps = 1.0 + valideps1 = nvl(epsilon1,defaulteps) + valideps2 = nvl(epsilon2,defaulteps) + return (0.0 < valideps1) and (valideps1 <= (derivationofeps * valideps2)) and (valideps2 <= (derivationofeps * valideps1)) and (valideps2 < uppereps) + + +def IfcSameValue(value1, value2, epsilon): + + defaulteps = 0.000001 + valideps = nvl(epsilon,defaulteps) + return ((value1 + valideps) > value2) and (value1 < (value2 + valideps)) + + +def IfcScalarTimesVector(scalar, vec): + + + + if (not exists(scalar)) or (not exists(vec)): + return None + else: + if 'ifc4x3_tc1.ifcvector' in typeof(vec): + v = vec.Orientation + mag = scalar * vec.Magnitude + else: + v = vec + mag = scalar + if mag < 0.0: + for i in range(1, sizeof(v.DirectionRatios) + 1): + temp = list(v.DirectionRatios) + temp[i - 1] = -v.DirectionRatios[i - 1] + v.DirectionRatios = temp + mag = -mag + result = IfcVector(Orientation=IfcNormalise(v), Magnitude=mag) + return result + + +def IfcSecondProjAxis(zaxis, xaxis, arg): + + + + if not exists(arg): + v = IfcDirection(DirectionRatios=[0.0,1.0,0.0]) + else: + v = arg + temp = IfcScalarTimesVector(IfcDotProduct(v,zaxis),zaxis) + yaxis = IfcVectorDifference(v,temp) + temp = IfcScalarTimesVector(IfcDotProduct(v,xaxis),xaxis) + yaxis = IfcVectorDifference(yaxis,temp) + yaxis = IfcNormalise(yaxis) + return yaxis.Orientation + + +def IfcSegmentDim(segment): + + if 'ifc4x3_tc1.ifccurvesegment' in typeof(segment): + return segment.ParentCurve.Dim + if 'ifc4x3_tc1.ifccompositecurvesegment' in typeof(segment): + return segment.ParentCurve.Dim + return None + + +def IfcShapeRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'point': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcpoint' in typeof(temp)]) + elif reptype.lower() == 'pointcloud': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifccartesianpointlist3d' in typeof(temp)]) + elif reptype.lower() == 'curve': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifccurve' in typeof(temp)]) + elif reptype.lower() == 'curve2d': + count = sizeof([temp for temp in items if ('ifc4x3_tc1.ifccurve' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'curve3d': + count = sizeof([temp for temp in items if ('ifc4x3_tc1.ifccurve' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'segment': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcsegment' in typeof(temp)]) + elif reptype.lower() == 'surface': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcsurface' in typeof(temp)]) + elif reptype.lower() == 'surface2d': + count = sizeof([temp for temp in items if ('ifc4x3_tc1.ifcsurface' in typeof(temp)) and (temp.Dim == 2)]) + elif reptype.lower() == 'surface3d': + count = sizeof([temp for temp in items if ('ifc4x3_tc1.ifcsurface' in typeof(temp)) and (temp.Dim == 3)]) + elif reptype.lower() == 'sectionedsurface': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcsectionedsurface' in typeof(temp)]) + elif reptype.lower() == 'fillarea': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcannotationfillarea' in typeof(temp)]) + elif reptype.lower() == 'text': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifctextliteral' in typeof(temp)]) + elif reptype.lower() == 'advancedsurface': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcbsplinesurface' in typeof(temp)]) + elif reptype.lower() == 'annotation2d': + count = sizeof([temp for temp in items if (sizeof(typeof(temp) * ['ifc4x3_tc1.ifcpoint','ifc4x3_tc1.ifccurve','ifc4x3_tc1.ifcgeometriccurveset','ifc4x3_tc1.ifcannotationfillarea','ifc4x3_tc1.ifctextliteral'])) == 1]) + elif reptype.lower() == 'geometricset': + count = sizeof([temp for temp in items if ('ifc4x3_tc1.ifcgeometricset' in typeof(temp)) or ('ifc4x3_tc1.ifcpoint' in typeof(temp)) or ('ifc4x3_tc1.ifccurve' in typeof(temp)) or ('ifc4x3_tc1.ifcsurface' in typeof(temp))]) + elif reptype.lower() == 'geometriccurveset': + count = sizeof([temp for temp in items if ('ifc4x3_tc1.ifcgeometriccurveset' in typeof(temp)) or ('ifc4x3_tc1.ifcgeometricset' in typeof(temp)) or ('ifc4x3_tc1.ifcpoint' in typeof(temp)) or ('ifc4x3_tc1.ifccurve' in typeof(temp))]) + for i in range(1, hiindex(items) + 1): + if 'ifc4x3_tc1.ifcgeometricset' in (typeof(items[i - 1])): + if (sizeof([temp for temp in items[i - 1].Elements if 'ifc4x3_tc1.ifcsurface' in typeof(temp)])) > 0: + count = count - 1 + elif reptype.lower() == 'tessellation': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifctessellateditem' in typeof(temp)]) + elif reptype.lower() == 'surfaceorsolidmodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_tc1.ifctessellateditem','ifc4x3_tc1.ifcshellbasedsurfacemodel','ifc4x3_tc1.ifcfacebasedsurfacemodel','ifc4x3_tc1.ifcsolidmodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'surfacemodel': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_tc1.ifctessellateditem','ifc4x3_tc1.ifcshellbasedsurfacemodel','ifc4x3_tc1.ifcfacebasedsurfacemodel'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'solidmodel': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcsolidmodel' in typeof(temp)]) + elif reptype.lower() == 'sweptsolid': + count = sizeof([temp for temp in items if ((sizeof(['ifc4x3_tc1.ifcextrudedareasolid','ifc4x3_tc1.ifcrevolvedareasolid'] * typeof(temp))) >= 1) and ((sizeof(['ifc4x3_tc1.ifcextrudedareasolidtapered','ifc4x3_tc1.ifcrevolvedareasolidtapered'] * typeof(temp))) == 0)]) + elif reptype.lower() == 'advancedsweptsolid': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_tc1.ifcsweptareasolid','ifc4x3_tc1.ifcsweptdisksolid','ifc4x3_tc1.ifcsectionedsolidhorizontal'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'csg': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_tc1.ifcbooleanresult','ifc4x3_tc1.ifccsgprimitive3d','ifc4x3_tc1.ifccsgsolid'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'clipping': + count = sizeof([temp for temp in items if (sizeof(['ifc4x3_tc1.ifccsgsolid','ifc4x3_tc1.ifcbooleanclippingresult'] * typeof(temp))) >= 1]) + elif reptype.lower() == 'brep': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcfacetedbrep' in typeof(temp)]) + elif reptype.lower() == 'advancedbrep': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcmanifoldsolidbrep' in typeof(temp)]) + elif reptype.lower() == 'boundingbox': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcboundingbox' in typeof(temp)]) + if sizeof(items) > 1: + count = 0 + elif reptype.lower() == 'sectionedspine': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcsectionedspine' in typeof(temp)]) + elif reptype.lower() == 'lightsource': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifclightsource' in typeof(temp)]) + elif reptype.lower() == 'mappedrepresentation': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcmappeditem' in typeof(temp)]) + else: + return None + return count == sizeof(items) + + +def IfcSurfaceWeightsPositive(b): + result = True + weights = b.Weights + for i in range(0, b.UUpper + 1): + for j in range(0, b.VUpper + 1): + if (weights[i - 1][j - 1]) <= 0.0: + result = False + return result + return result + + +def IfcTaperedSweptAreaProfiles(startarea, endarea): + result = False + if 'ifc4x3_tc1.ifcparameterizedprofiledef' in typeof(startarea): + if 'ifc4x3_tc1.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = typeof(startarea) == typeof(endarea) + else: + if 'ifc4x3_tc1.ifcderivedprofiledef' in typeof(endarea): + result = startarea == endarea.ParentProfile + else: + result = False + return result + + +def IfcTopologyRepresentationTypes(reptype, items): + count = 0 + if reptype.lower() == 'vertex': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcvertex' in typeof(temp)]) + elif reptype.lower() == 'edge': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcedge' in typeof(temp)]) + elif reptype.lower() == 'path': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcpath' in typeof(temp)]) + elif reptype.lower() == 'face': + count = sizeof([temp for temp in items if 'ifc4x3_tc1.ifcface' in typeof(temp)]) + elif reptype.lower() == 'shell': + count = sizeof([temp for temp in items if ('ifc4x3_tc1.ifcopenshell' in typeof(temp)) or ('ifc4x3_tc1.ifcclosedshell' in typeof(temp))]) + elif reptype.lower() == 'undefined': + return True + else: + return None + return count == sizeof(items) + + +def IfcUniqueDefinitionNames(relations): + + + properties = express_set([]) + + if sizeof(relations) == 0: + return True + for i in range(1, hiindex(relations) + 1): + definition = relations[i - 1].RelatingPropertyDefinition + if 'ifc4x3_tc1.ifcpropertysetdefinition' in typeof(definition): + properties = properties + definition + else: + if 'ifc4x3_tc1.ifcpropertysetdefinitionset' in typeof(definition): + definitionset = definition + for j in range(1, hiindex(definitionset) + 1): + properties = properties + (definitionset[j - 1]) + result = IfcUniquePropertySetNames(properties) + return result + + +def IfcUniquePropertyName(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniquePropertySetNames(properties): + names = express_set([]) + unnamed = 0 + for i in range(1, hiindex(properties) + 1): + if 'ifc4x3_tc1.ifcpropertyset' in (typeof(properties[i - 1])): + names = names + (properties[i - 1].Name) + else: + unnamed = unnamed + 1 + return (sizeof(names) + unnamed) == sizeof(properties) + + +def IfcUniquePropertyTemplateNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcUniqueQuantityNames(properties): + names = express_set([]) + for i in range(1, hiindex(properties) + 1): + names = names + (properties[i - 1].Name) + return sizeof(names) == sizeof(properties) + + +def IfcVectorDifference(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x3_tc1.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x3_tc1.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) - (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + +def IfcVectorSum(arg1, arg2): + + + + + if ((not exists(arg1)) or (not exists(arg2))) or (arg1.Dim != arg2.Dim): + return None + else: + if 'ifc4x3_tc1.ifcvector' in typeof(arg1): + mag1 = arg1.Magnitude + vec1 = arg1.Orientation + else: + mag1 = 1.0 + vec1 = arg1 + if 'ifc4x3_tc1.ifcvector' in typeof(arg2): + mag2 = arg2.Magnitude + vec2 = arg2.Orientation + else: + mag2 = 1.0 + vec2 = arg2 + vec1 = IfcNormalise(vec1) + vec2 = IfcNormalise(vec2) + ndim = sizeof(vec1.DirectionRatios) + mag = 0.0 + res = IfcDirection(DirectionRatios=([0.0] * ndim)) + for i in range(1, ndim + 1): + temp = list(res.DirectionRatios) + temp[i - 1] = (mag1 * (vec1.DirectionRatios[i - 1])) + (mag2 * (vec2.DirectionRatios[i - 1])) + res.DirectionRatios = temp + mag = mag + ((res.DirectionRatios[i - 1]) * (res.DirectionRatios[i - 1])) + if mag > 0.0: + result = IfcVector(Orientation=res, Magnitude=sqrt(mag)) + else: + result = IfcVector(Orientation=vec1, Magnitude=0.0) + return result + + diff --git a/src/ifcopenshell-python/ifcopenshell/express/rules/__init__.py b/src/ifcopenshell-python/ifcopenshell/express/rules/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/ifcopenshell-python/ifcopenshell/express/schema.py b/src/ifcopenshell-python/ifcopenshell/express/schema.py index ed217d3123..38e1053692 100644 --- a/src/ifcopenshell-python/ifcopenshell/express/schema.py +++ b/src/ifcopenshell-python/ifcopenshell/express/schema.py @@ -81,25 +81,33 @@ class Schema: return iter(self.keys) def __getitem__(self, key): - return self.types_entities[key] + return self.all_declarations[OrderedCaseInsensitiveDict_KeyObject(key)] def __init__(self, parsetree): self.tree = parsetree - self.name = parsetree.syntax[0][0].simple_id + schema = next(iter(parsetree.syntax[0])) + self.name = schema.simple_id + schema_declarations = list(schema.schema_body[0]) sort = lambda d: OrderedCaseInsensitiveDict(sorted(d)) declarations = [ d.any()[0] - for d in parsetree.syntax[0][0].schema_body[0] - if d.rule == "declaration" and d.any()[0].rule != "function_decl" + for d in schema_declarations + if d.rule == "declaration" + ] + [ + d + for d in schema_declarations + if d.rule == "RuleDeclaration" ] - + self.types = sort([(t.name, t) for t in declarations if isinstance(t, nodes.TypeDeclaration)]) self.entities = sort([(t.name, t) for t in declarations if isinstance(t, nodes.EntityDeclaration)]) + self.rules = sort([(t.name, t) for t in declarations if isinstance(t, nodes.RuleDeclaration)]) + self.functions = sort([(t.name, t) for t in declarations if isinstance(t, nodes.FunctionDeclaration)]) - self.keys = list(self.types.keys()) + list(self.entities.keys()) - self.types_entities = {k: v for d in (self.types, self.entities) for k, v in d.items()} + self.keys = list(self.types.keys()) + list(self.entities.keys()) + list(self.rules.keys()) + list(self.functions.keys()) + self.all_declarations = {k: v for d in (self.types, self.entities, self.rules, self.functions) for k, v in d.items()} of_type = lambda *types: sort( [(a, b.type) for a, b in self.types.items() if any(isinstance(b.type, ty) for ty in types)] diff --git a/src/ifcopenshell-python/ifcopenshell/express/schema_class.py b/src/ifcopenshell-python/ifcopenshell/express/schema_class.py index ba38778175..1c89db6973 100644 --- a/src/ifcopenshell-python/ifcopenshell/express/schema_class.py +++ b/src/ifcopenshell-python/ifcopenshell/express/schema_class.py @@ -410,7 +410,7 @@ class SchemaClass(codegen.Base): x.begin_schema() emitted = set() - len_to_emit = len(mapping.schema) + len_to_emit = len(mapping.schema) - len(mapping.schema.rules) - len(mapping.schema.functions) def write_simpletype(schema_name, name, type): try: @@ -446,6 +446,10 @@ class SchemaClass(codegen.Base): fn = write_entity elif mapping.schema.is_select(name): fn = write_select + elif name in mapping.schema.rules: + return + elif name in mapping.schema.functions: + return decl = mapping.schema[name] if isinstance(decl, nodes.TypeDeclaration): diff --git a/src/ifcopenshell-python/ifcopenshell/ifcopenshell_wrapper.py b/src/ifcopenshell-python/ifcopenshell/ifcopenshell_wrapper.py new file mode 100644 index 0000000000..511ab95394 --- /dev/null +++ b/src/ifcopenshell-python/ifcopenshell/ifcopenshell_wrapper.py @@ -0,0 +1,5902 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 3.0.12 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. + +from sys import version_info as _swig_python_version_info +if _swig_python_version_info >= (2, 7, 0): + def swig_import_helper(): + import importlib + pkg = __name__.rpartition('.')[0] + mname = '.'.join((pkg, '_ifcopenshell_wrapper')).lstrip('.') + try: + return importlib.import_module(mname) + except ImportError: + return importlib.import_module('_ifcopenshell_wrapper') + _ifcopenshell_wrapper = swig_import_helper() + del swig_import_helper +elif _swig_python_version_info >= (2, 6, 0): + def swig_import_helper(): + from os.path import dirname + import imp + fp = None + try: + fp, pathname, description = imp.find_module('_ifcopenshell_wrapper', [dirname(__file__)]) + except ImportError: + import _ifcopenshell_wrapper + return _ifcopenshell_wrapper + try: + _mod = imp.load_module('_ifcopenshell_wrapper', fp, pathname, description) + finally: + if fp is not None: + fp.close() + return _mod + _ifcopenshell_wrapper = swig_import_helper() + del swig_import_helper +else: + import _ifcopenshell_wrapper +del _swig_python_version_info + +try: + _swig_property = property +except NameError: + pass # Python < 2.2 doesn't have 'property'. + +try: + import builtins as __builtin__ +except ImportError: + import __builtin__ + +def _swig_setattr_nondynamic(self, class_type, name, value, static=1): + if (name == "thisown"): + return self.this.own(value) + if (name == "this"): + if type(value).__name__ == 'SwigPyObject': + self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name, None) + if method: + return method(self, value) + if (not static): + if _newclass: + object.__setattr__(self, name, value) + else: + self.__dict__[name] = value + else: + raise AttributeError("You cannot add attributes to %s" % self) + + +def _swig_setattr(self, class_type, name, value): + return _swig_setattr_nondynamic(self, class_type, name, value, 0) + + +def _swig_getattr(self, class_type, name): + if (name == "thisown"): + return self.this.own() + method = class_type.__swig_getmethods__.get(name, None) + if method: + return method(self) + raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name)) + + +def _swig_repr(self): + try: + strthis = "proxy of " + self.this.__repr__() + except __builtin__.Exception: + strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + +try: + _object = object + _newclass = 1 +except __builtin__.Exception: + class _object: + pass + _newclass = 0 + +class SwigPyIterator(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name) + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _ifcopenshell_wrapper.delete_SwigPyIterator + __del__ = lambda self: None + + def value(self): + return _ifcopenshell_wrapper.SwigPyIterator_value(self) + + def incr(self, n=1): + return _ifcopenshell_wrapper.SwigPyIterator_incr(self, n) + + def decr(self, n=1): + return _ifcopenshell_wrapper.SwigPyIterator_decr(self, n) + + def distance(self, x): + return _ifcopenshell_wrapper.SwigPyIterator_distance(self, x) + + def equal(self, x): + return _ifcopenshell_wrapper.SwigPyIterator_equal(self, x) + + def copy(self): + return _ifcopenshell_wrapper.SwigPyIterator_copy(self) + + def next(self): + return _ifcopenshell_wrapper.SwigPyIterator_next(self) + + def __next__(self): + return _ifcopenshell_wrapper.SwigPyIterator___next__(self) + + def previous(self): + return _ifcopenshell_wrapper.SwigPyIterator_previous(self) + + def advance(self, n): + return _ifcopenshell_wrapper.SwigPyIterator_advance(self, n) + + def __eq__(self, x): + return _ifcopenshell_wrapper.SwigPyIterator___eq__(self, x) + + def __ne__(self, x): + return _ifcopenshell_wrapper.SwigPyIterator___ne__(self, x) + + def __iadd__(self, n): + return _ifcopenshell_wrapper.SwigPyIterator___iadd__(self, n) + + def __isub__(self, n): + return _ifcopenshell_wrapper.SwigPyIterator___isub__(self, n) + + def __add__(self, n): + return _ifcopenshell_wrapper.SwigPyIterator___add__(self, n) + + def __sub__(self, *args): + return _ifcopenshell_wrapper.SwigPyIterator___sub__(self, *args) + def __iter__(self): + return self +SwigPyIterator_swigregister = _ifcopenshell_wrapper.SwigPyIterator_swigregister +SwigPyIterator_swigregister(SwigPyIterator) + +class IteratorSettings(_object): + """Proxy of C++ IfcGeom::IteratorSettings class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, IteratorSettings, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, IteratorSettings, name) + __repr__ = _swig_repr + WELD_VERTICES = _ifcopenshell_wrapper.IteratorSettings_WELD_VERTICES + USE_WORLD_COORDS = _ifcopenshell_wrapper.IteratorSettings_USE_WORLD_COORDS + CONVERT_BACK_UNITS = _ifcopenshell_wrapper.IteratorSettings_CONVERT_BACK_UNITS + USE_BREP_DATA = _ifcopenshell_wrapper.IteratorSettings_USE_BREP_DATA + SEW_SHELLS = _ifcopenshell_wrapper.IteratorSettings_SEW_SHELLS + DISABLE_OPENING_SUBTRACTIONS = _ifcopenshell_wrapper.IteratorSettings_DISABLE_OPENING_SUBTRACTIONS + DISABLE_TRIANGULATION = _ifcopenshell_wrapper.IteratorSettings_DISABLE_TRIANGULATION + APPLY_DEFAULT_MATERIALS = _ifcopenshell_wrapper.IteratorSettings_APPLY_DEFAULT_MATERIALS + INCLUDE_CURVES = _ifcopenshell_wrapper.IteratorSettings_INCLUDE_CURVES + EXCLUDE_SOLIDS_AND_SURFACES = _ifcopenshell_wrapper.IteratorSettings_EXCLUDE_SOLIDS_AND_SURFACES + NO_NORMALS = _ifcopenshell_wrapper.IteratorSettings_NO_NORMALS + GENERATE_UVS = _ifcopenshell_wrapper.IteratorSettings_GENERATE_UVS + APPLY_LAYERSETS = _ifcopenshell_wrapper.IteratorSettings_APPLY_LAYERSETS + ELEMENT_HIERARCHY = _ifcopenshell_wrapper.IteratorSettings_ELEMENT_HIERARCHY + SITE_LOCAL_PLACEMENT = _ifcopenshell_wrapper.IteratorSettings_SITE_LOCAL_PLACEMENT + BUILDING_LOCAL_PLACEMENT = _ifcopenshell_wrapper.IteratorSettings_BUILDING_LOCAL_PLACEMENT + VALIDATE_QUANTITIES = _ifcopenshell_wrapper.IteratorSettings_VALIDATE_QUANTITIES + LAYERSET_FIRST = _ifcopenshell_wrapper.IteratorSettings_LAYERSET_FIRST + EDGE_ARROWS = _ifcopenshell_wrapper.IteratorSettings_EDGE_ARROWS + DISABLE_BOOLEAN_RESULT = _ifcopenshell_wrapper.IteratorSettings_DISABLE_BOOLEAN_RESULT + NO_WIRE_INTERSECTION_CHECK = _ifcopenshell_wrapper.IteratorSettings_NO_WIRE_INTERSECTION_CHECK + NO_WIRE_INTERSECTION_TOLERANCE = _ifcopenshell_wrapper.IteratorSettings_NO_WIRE_INTERSECTION_TOLERANCE + STRICT_TOLERANCE = _ifcopenshell_wrapper.IteratorSettings_STRICT_TOLERANCE + DEBUG_BOOLEAN = _ifcopenshell_wrapper.IteratorSettings_DEBUG_BOOLEAN + BOOLEAN_ATTEMPT_2D = _ifcopenshell_wrapper.IteratorSettings_BOOLEAN_ATTEMPT_2D + NUM_SETTINGS = _ifcopenshell_wrapper.IteratorSettings_NUM_SETTINGS + + def __init__(self): + """__init__(IfcGeom::IteratorSettings self) -> IteratorSettings""" + this = _ifcopenshell_wrapper.new_IteratorSettings() + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def deflection_tolerance(self): + """deflection_tolerance(IteratorSettings self) -> double""" + return _ifcopenshell_wrapper.IteratorSettings_deflection_tolerance(self) + + + def angular_tolerance(self): + """angular_tolerance(IteratorSettings self) -> double""" + return _ifcopenshell_wrapper.IteratorSettings_angular_tolerance(self) + + + def context_ids(self): + """context_ids(IteratorSettings self) -> std::set< int >""" + return _ifcopenshell_wrapper.IteratorSettings_context_ids(self) + + + def set_deflection_tolerance(self, value): + """set_deflection_tolerance(IteratorSettings self, double value)""" + return _ifcopenshell_wrapper.IteratorSettings_set_deflection_tolerance(self, value) + + + def set_angular_tolerance(self, value): + """set_angular_tolerance(IteratorSettings self, double value)""" + return _ifcopenshell_wrapper.IteratorSettings_set_angular_tolerance(self, value) + + + def force_space_transparency(self, *args): + """ + force_space_transparency(IteratorSettings self) -> double + force_space_transparency(IteratorSettings self, double value) + """ + return _ifcopenshell_wrapper.IteratorSettings_force_space_transparency(self, *args) + + + def set_context_ids(self, value): + """set_context_ids(IteratorSettings self, std::vector< int,std::allocator< int > > value)""" + return _ifcopenshell_wrapper.IteratorSettings_set_context_ids(self, value) + + + def get(self, setting): + """get(IteratorSettings self, uint64_t setting) -> bool""" + return _ifcopenshell_wrapper.IteratorSettings_get(self, setting) + + + def set(self, setting, value): + """set(IteratorSettings self, uint64_t setting, bool value)""" + return _ifcopenshell_wrapper.IteratorSettings_set(self, setting, value) + + __swig_setmethods__["offset"] = _ifcopenshell_wrapper.IteratorSettings_offset_set + __swig_getmethods__["offset"] = _ifcopenshell_wrapper.IteratorSettings_offset_get + if _newclass: + offset = _swig_property(_ifcopenshell_wrapper.IteratorSettings_offset_get, _ifcopenshell_wrapper.IteratorSettings_offset_set) + __swig_setmethods__["rotation"] = _ifcopenshell_wrapper.IteratorSettings_rotation_set + __swig_getmethods__["rotation"] = _ifcopenshell_wrapper.IteratorSettings_rotation_get + if _newclass: + rotation = _swig_property(_ifcopenshell_wrapper.IteratorSettings_rotation_get, _ifcopenshell_wrapper.IteratorSettings_rotation_set) + + def get_raw(self): + """get_raw(IteratorSettings self) -> uint64_t""" + return _ifcopenshell_wrapper.IteratorSettings_get_raw(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_IteratorSettings + __del__ = lambda self: None +IteratorSettings_swigregister = _ifcopenshell_wrapper.IteratorSettings_swigregister +IteratorSettings_swigregister(IteratorSettings) + +class ElementSettings(IteratorSettings): + """Proxy of C++ IfcGeom::ElementSettings class.""" + + __swig_setmethods__ = {} + for _s in [IteratorSettings]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, ElementSettings, name, value) + __swig_getmethods__ = {} + for _s in [IteratorSettings]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, ElementSettings, name) + __repr__ = _swig_repr + + def __init__(self, settings, unit_magnitude, element_type): + """__init__(IfcGeom::ElementSettings self, IteratorSettings settings, double unit_magnitude, std::string const & element_type) -> ElementSettings""" + this = _ifcopenshell_wrapper.new_ElementSettings(settings, unit_magnitude, element_type) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def unit_magnitude(self): + """unit_magnitude(ElementSettings self) -> double""" + return _ifcopenshell_wrapper.ElementSettings_unit_magnitude(self) + + + def element_type(self): + """element_type(ElementSettings self) -> std::string const &""" + return _ifcopenshell_wrapper.ElementSettings_element_type(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_ElementSettings + __del__ = lambda self: None +ElementSettings_swigregister = _ifcopenshell_wrapper.ElementSettings_swigregister +ElementSettings_swigregister(ElementSettings) + +class Matrix(_object): + """Proxy of C++ IfcGeom::Matrix class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, Matrix, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, Matrix, name) + __repr__ = _swig_repr + + def __init__(self, settings, trsf): + """__init__(IfcGeom::Matrix self, ElementSettings settings, gp_Trsf const & trsf) -> Matrix""" + this = _ifcopenshell_wrapper.new_Matrix(settings, trsf) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def data(self): + """data(Matrix self) -> std::vector< double,std::allocator< double > > const &""" + return _ifcopenshell_wrapper.Matrix_data(self) + + + # Hide the getters with read-only property implementations + data = property(data) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_Matrix + __del__ = lambda self: None +Matrix_swigregister = _ifcopenshell_wrapper.Matrix_swigregister +Matrix_swigregister(Matrix) + +class Transformation(_object): + """Proxy of C++ IfcGeom::Transformation class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, Transformation, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, Transformation, name) + __repr__ = _swig_repr + + def __init__(self, settings, trsf): + """__init__(IfcGeom::Transformation self, ElementSettings settings, gp_Trsf const & trsf) -> Transformation""" + this = _ifcopenshell_wrapper.new_Transformation(settings, trsf) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def data(self): + """data(Transformation self) -> gp_Trsf const &""" + return _ifcopenshell_wrapper.Transformation_data(self) + + + def matrix(self): + """matrix(Transformation self) -> Matrix""" + return _ifcopenshell_wrapper.Transformation_matrix(self) + + + def inverted(self): + """inverted(Transformation self) -> Transformation""" + return _ifcopenshell_wrapper.Transformation_inverted(self) + + + def multiplied(self, other): + """multiplied(Transformation self, Transformation other) -> Transformation""" + return _ifcopenshell_wrapper.Transformation_multiplied(self, other) + + + # Hide the getters with read-only property implementations + matrix = property(matrix) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_Transformation + __del__ = lambda self: None +Transformation_swigregister = _ifcopenshell_wrapper.Transformation_swigregister +Transformation_swigregister(Transformation) + +class Element(_object): + """Proxy of C++ IfcGeom::Element class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, Element, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, Element, name) + __repr__ = _swig_repr + + def id(self): + """id(Element self) -> int""" + return _ifcopenshell_wrapper.Element_id(self) + + + def parent_id(self): + """parent_id(Element self) -> int""" + return _ifcopenshell_wrapper.Element_parent_id(self) + + + def name(self): + """name(Element self) -> std::string const &""" + return _ifcopenshell_wrapper.Element_name(self) + + + def type(self): + """type(Element self) -> std::string const &""" + return _ifcopenshell_wrapper.Element_type(self) + + + def guid(self): + """guid(Element self) -> std::string const &""" + return _ifcopenshell_wrapper.Element_guid(self) + + + def context(self): + """context(Element self) -> std::string const &""" + return _ifcopenshell_wrapper.Element_context(self) + + + def unique_id(self): + """unique_id(Element self) -> std::string const &""" + return _ifcopenshell_wrapper.Element_unique_id(self) + + + def transformation(self): + """transformation(Element self) -> Transformation""" + return _ifcopenshell_wrapper.Element_transformation(self) + + + def product(self): + """product(Element self) -> IfcBaseEntity""" + return _ifcopenshell_wrapper.Element_product(self) + + + def parents(self): + """parents(Element self) -> std::vector< IfcGeom::Element const *,std::allocator< IfcGeom::Element const * > > const""" + return _ifcopenshell_wrapper.Element_parents(self) + + + def SetParents(self, newparents): + """SetParents(Element self, std::vector< IfcGeom::Element const *,std::allocator< IfcGeom::Element const * > > newparents)""" + return _ifcopenshell_wrapper.Element_SetParents(self, newparents) + + + def __init__(self, settings, id, parent_id, name, type, guid, context, trsf, product): + """__init__(IfcGeom::Element self, ElementSettings settings, int id, int parent_id, std::string const & name, std::string const & type, std::string const & guid, std::string const & context, gp_Trsf const & trsf, IfcBaseEntity product) -> Element""" + this = _ifcopenshell_wrapper.new_Element(settings, id, parent_id, name, type, guid, context, trsf, product) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_Element + __del__ = lambda self: None + + def product_(self): + """product_(Element self) -> entity_instance""" + return _ifcopenshell_wrapper.Element_product_(self) + + + # Hide the getters with read-only property implementations + id = property(id) + parent_id = property(parent_id) + name = property(name) + type = property(type) + guid = property(guid) + context = property(context) + unique_id = property(unique_id) + transformation = property(transformation) + product = property(product_) + +Element_swigregister = _ifcopenshell_wrapper.Element_swigregister +Element_swigregister(Element) + +def __eq__(element1, element2): + """__eq__(Element element1, Element element2) -> bool""" + return _ifcopenshell_wrapper.__eq__(element1, element2) + +def __lt__(element1, element2): + """__lt__(Element element1, Element element2) -> bool""" + return _ifcopenshell_wrapper.__lt__(element1, element2) + +class BRepElement(Element): + """Proxy of C++ IfcGeom::BRepElement class.""" + + __swig_setmethods__ = {} + for _s in [Element]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, BRepElement, name, value) + __swig_getmethods__ = {} + for _s in [Element]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, BRepElement, name) + __repr__ = _swig_repr + + def geometry_pointer(self): + """geometry_pointer(BRepElement self) -> boost::shared_ptr< IfcGeom::Representation::BRep > const &""" + return _ifcopenshell_wrapper.BRepElement_geometry_pointer(self) + + + def geometry(self): + """geometry(BRepElement self) -> BRep""" + return _ifcopenshell_wrapper.BRepElement_geometry(self) + + + def __init__(self, id, parent_id, name, type, guid, context, trsf, geometry, product): + """__init__(IfcGeom::BRepElement self, int id, int parent_id, std::string const & name, std::string const & type, std::string const & guid, std::string const & context, gp_Trsf const & trsf, boost::shared_ptr< IfcGeom::Representation::BRep > const & geometry, IfcBaseEntity product) -> BRepElement""" + this = _ifcopenshell_wrapper.new_BRepElement(id, parent_id, name, type, guid, context, trsf, geometry, product) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def calculate_projected_surface_area(self, along_x, along_y, along_z): + """calculate_projected_surface_area(BRepElement self, double & along_x, double & along_y, double & along_z) -> bool""" + return _ifcopenshell_wrapper.BRepElement_calculate_projected_surface_area(self, along_x, along_y, along_z) + + + def calc_volume_(self): + """calc_volume_(BRepElement self) -> double""" + return _ifcopenshell_wrapper.BRepElement_calc_volume_(self) + + + def calc_surface_area_(self): + """calc_surface_area_(BRepElement self) -> double""" + return _ifcopenshell_wrapper.BRepElement_calc_surface_area_(self) + + + # Hide the getters with read-only property implementations + geometry = property(geometry) + volume = property(calc_volume_) + surface_area = property(calc_surface_area_) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_BRepElement + __del__ = lambda self: None +BRepElement_swigregister = _ifcopenshell_wrapper.BRepElement_swigregister +BRepElement_swigregister(BRepElement) + +class TriangulationElement(Element): + """Proxy of C++ IfcGeom::TriangulationElement class.""" + + __swig_setmethods__ = {} + for _s in [Element]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, TriangulationElement, name, value) + __swig_getmethods__ = {} + for _s in [Element]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, TriangulationElement, name) + __repr__ = _swig_repr + + def geometry(self): + """geometry(TriangulationElement self) -> Triangulation""" + return _ifcopenshell_wrapper.TriangulationElement_geometry(self) + + + def geometry_pointer(self): + """geometry_pointer(TriangulationElement self) -> boost::shared_ptr< IfcGeom::Representation::Triangulation > const &""" + return _ifcopenshell_wrapper.TriangulationElement_geometry_pointer(self) + + + def __init__(self, *args): + """ + __init__(IfcGeom::TriangulationElement self, BRepElement shape_model) -> TriangulationElement + __init__(IfcGeom::TriangulationElement self, Element element, boost::shared_ptr< IfcGeom::Representation::Triangulation > const & geometry) -> TriangulationElement + """ + this = _ifcopenshell_wrapper.new_TriangulationElement(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + # Hide the getters with read-only property implementations + geometry = property(geometry) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_TriangulationElement + __del__ = lambda self: None +TriangulationElement_swigregister = _ifcopenshell_wrapper.TriangulationElement_swigregister +TriangulationElement_swigregister(TriangulationElement) + +class SerializedElement(Element): + """Proxy of C++ IfcGeom::SerializedElement class.""" + + __swig_setmethods__ = {} + for _s in [Element]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, SerializedElement, name, value) + __swig_getmethods__ = {} + for _s in [Element]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, SerializedElement, name) + __repr__ = _swig_repr + + def geometry(self): + """geometry(SerializedElement self) -> Serialization""" + return _ifcopenshell_wrapper.SerializedElement_geometry(self) + + + def __init__(self, shape_model): + """__init__(IfcGeom::SerializedElement self, BRepElement shape_model) -> SerializedElement""" + this = _ifcopenshell_wrapper.new_SerializedElement(shape_model) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_SerializedElement + __del__ = lambda self: None + + # Hide the getters with read-only property implementations + geometry = property(geometry) + +SerializedElement_swigregister = _ifcopenshell_wrapper.SerializedElement_swigregister +SerializedElement_swigregister(SerializedElement) + +class Material(_object): + """Proxy of C++ IfcGeom::Material class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, Material, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, Material, name) + __repr__ = _swig_repr + + def __init__(self, *args): + """ + __init__(IfcGeom::Material self) -> Material + __init__(IfcGeom::Material self, std::shared_ptr< IfcGeom::SurfaceStyle const > const & arg2) -> Material + """ + this = _ifcopenshell_wrapper.new_Material(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def hasDiffuse(self): + """hasDiffuse(Material self) -> bool""" + return _ifcopenshell_wrapper.Material_hasDiffuse(self) + + + def hasSpecular(self): + """hasSpecular(Material self) -> bool""" + return _ifcopenshell_wrapper.Material_hasSpecular(self) + + + def hasTransparency(self): + """hasTransparency(Material self) -> bool""" + return _ifcopenshell_wrapper.Material_hasTransparency(self) + + + def hasSpecularity(self): + """hasSpecularity(Material self) -> bool""" + return _ifcopenshell_wrapper.Material_hasSpecularity(self) + + + def diffuse(self): + """diffuse(Material self) -> double const *""" + return _ifcopenshell_wrapper.Material_diffuse(self) + + + def specular(self): + """specular(Material self) -> double const *""" + return _ifcopenshell_wrapper.Material_specular(self) + + + def transparency(self): + """transparency(Material self) -> double""" + return _ifcopenshell_wrapper.Material_transparency(self) + + + def specularity(self): + """specularity(Material self) -> double""" + return _ifcopenshell_wrapper.Material_specularity(self) + + + def name(self): + """name(Material self) -> std::string const &""" + return _ifcopenshell_wrapper.Material_name(self) + + + def original_name(self): + """original_name(Material self) -> std::string const &""" + return _ifcopenshell_wrapper.Material_original_name(self) + + + def __eq__(self, other): + """__eq__(Material self, Material other) -> bool""" + return _ifcopenshell_wrapper.Material___eq__(self, other) + + + def get_style(self): + """get_style(Material self) -> IfcGeom::SurfaceStyle const &""" + return _ifcopenshell_wrapper.Material_get_style(self) + + + # Hide the getters with read-only property implementations + has_diffuse = property(hasDiffuse) + has_specular = property(hasSpecular) + has_transparency = property(hasTransparency) + has_specularity = property(hasSpecularity) + diffuse = property(diffuse) + specular = property(specular) + transparency = property(transparency) + specularity = property(specularity) + name = property(name) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_Material + __del__ = lambda self: None +Material_swigregister = _ifcopenshell_wrapper.Material_swigregister +Material_swigregister(Material) + +class Representation(_object): + """Proxy of C++ IfcGeom::Representation::Representation class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, Representation, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, Representation, name) + __repr__ = _swig_repr + + def __init__(self, settings): + """__init__(IfcGeom::Representation::Representation self, ElementSettings settings) -> Representation""" + this = _ifcopenshell_wrapper.new_Representation(settings) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def settings(self): + """settings(Representation self) -> ElementSettings""" + return _ifcopenshell_wrapper.Representation_settings(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_Representation + __del__ = lambda self: None +Representation_swigregister = _ifcopenshell_wrapper.Representation_swigregister +Representation_swigregister(Representation) + +class BRep(Representation): + """Proxy of C++ IfcGeom::Representation::BRep class.""" + + __swig_setmethods__ = {} + for _s in [Representation]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, BRep, name, value) + __swig_getmethods__ = {} + for _s in [Representation]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, BRep, name) + __repr__ = _swig_repr + + def __init__(self, settings, id, shapes): + """__init__(IfcGeom::Representation::BRep self, ElementSettings settings, std::string const & id, IfcGeom::IfcRepresentationShapeItems const & shapes) -> BRep""" + this = _ifcopenshell_wrapper.new_BRep(settings, id, shapes) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_BRep + __del__ = lambda self: None + + def begin(self): + """begin(BRep self) -> IfcGeom::IfcRepresentationShapeItems::const_iterator""" + return _ifcopenshell_wrapper.BRep_begin(self) + + + def end(self): + """end(BRep self) -> IfcGeom::IfcRepresentationShapeItems::const_iterator""" + return _ifcopenshell_wrapper.BRep_end(self) + + + def shapes(self): + """shapes(BRep self) -> IfcGeom::IfcRepresentationShapeItems const &""" + return _ifcopenshell_wrapper.BRep_shapes(self) + + + def id(self): + """id(BRep self) -> std::string const &""" + return _ifcopenshell_wrapper.BRep_id(self) + + + def as_compound(self, force_meters=False): + """ + as_compound(BRep self, bool force_meters=False) -> TopoDS_Compound + as_compound(BRep self) -> TopoDS_Compound + """ + return _ifcopenshell_wrapper.BRep_as_compound(self, force_meters) + + + def calculate_volume(self, arg2): + """calculate_volume(BRep self, double & arg2) -> bool""" + return _ifcopenshell_wrapper.BRep_calculate_volume(self, arg2) + + + def calculate_surface_area(self, arg2): + """calculate_surface_area(BRep self, double & arg2) -> bool""" + return _ifcopenshell_wrapper.BRep_calculate_surface_area(self, arg2) + + + def calculate_projected_surface_area(self, ax, along_x, along_y, along_z): + """calculate_projected_surface_area(BRep self, gp_Ax3 const & ax, double & along_x, double & along_y, double & along_z) -> bool""" + return _ifcopenshell_wrapper.BRep_calculate_projected_surface_area(self, ax, along_x, along_y, along_z) + +BRep_swigregister = _ifcopenshell_wrapper.BRep_swigregister +BRep_swigregister(BRep) + +class Serialization(Representation): + """Proxy of C++ IfcGeom::Representation::Serialization class.""" + + __swig_setmethods__ = {} + for _s in [Representation]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, Serialization, name, value) + __swig_getmethods__ = {} + for _s in [Representation]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, Serialization, name) + __repr__ = _swig_repr + + def brep_data(self): + """brep_data(Serialization self) -> std::string const &""" + return _ifcopenshell_wrapper.Serialization_brep_data(self) + + + def surface_styles(self): + """surface_styles(Serialization self) -> std::vector< double,std::allocator< double > > const &""" + return _ifcopenshell_wrapper.Serialization_surface_styles(self) + + + def surface_style_ids(self): + """surface_style_ids(Serialization self) -> std::vector< int,std::allocator< int > > const &""" + return _ifcopenshell_wrapper.Serialization_surface_style_ids(self) + + + def __init__(self, brep): + """__init__(IfcGeom::Representation::Serialization self, BRep brep) -> Serialization""" + this = _ifcopenshell_wrapper.new_Serialization(brep) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_Serialization + __del__ = lambda self: None + + def id(self): + """id(Serialization self) -> std::string const &""" + return _ifcopenshell_wrapper.Serialization_id(self) + + + # Hide the getters with read-only property implementations + id = property(id) + brep_data = property(brep_data) + surface_styles = property(surface_styles) + surface_style_ids = property(surface_style_ids) + +Serialization_swigregister = _ifcopenshell_wrapper.Serialization_swigregister +Serialization_swigregister(Serialization) + +class Triangulation(Representation): + """Proxy of C++ IfcGeom::Representation::Triangulation class.""" + + __swig_setmethods__ = {} + for _s in [Representation]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, Triangulation, name, value) + __swig_getmethods__ = {} + for _s in [Representation]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, Triangulation, name) + __repr__ = _swig_repr + + def id(self): + """id(Triangulation self) -> std::string const &""" + return _ifcopenshell_wrapper.Triangulation_id(self) + + + def verts(self): + """verts(Triangulation self) -> std::vector< double,std::allocator< double > > const &""" + return _ifcopenshell_wrapper.Triangulation_verts(self) + + + def faces(self): + """faces(Triangulation self) -> std::vector< int,std::allocator< int > > const &""" + return _ifcopenshell_wrapper.Triangulation_faces(self) + + + def edges(self): + """edges(Triangulation self) -> std::vector< int,std::allocator< int > > const &""" + return _ifcopenshell_wrapper.Triangulation_edges(self) + + + def normals(self): + """normals(Triangulation self) -> std::vector< double,std::allocator< double > > const &""" + return _ifcopenshell_wrapper.Triangulation_normals(self) + + + def uvs(self): + """uvs(Triangulation self) -> std::vector< double,std::allocator< double > > const &""" + return _ifcopenshell_wrapper.Triangulation_uvs(self) + + + def material_ids(self): + """material_ids(Triangulation self) -> std::vector< int,std::allocator< int > > const &""" + return _ifcopenshell_wrapper.Triangulation_material_ids(self) + + + def materials(self): + """materials(Triangulation self) -> std::vector< IfcGeom::Material,std::allocator< IfcGeom::Material > > const &""" + return _ifcopenshell_wrapper.Triangulation_materials(self) + + + def __init__(self, *args): + """ + __init__(IfcGeom::Representation::Triangulation self, BRep shape_model) -> Triangulation + __init__(IfcGeom::Representation::Triangulation self, ElementSettings settings, std::string const & id, std::vector< double,std::allocator< double > > const & verts, std::vector< int,std::allocator< int > > const & faces, std::vector< int,std::allocator< int > > const & edges, std::vector< double,std::allocator< double > > const & normals, std::vector< double,std::allocator< double > > const & uvs, std::vector< int,std::allocator< int > > const & material_ids, std::vector< std::shared_ptr< IfcGeom::SurfaceStyle >,std::allocator< std::shared_ptr< IfcGeom::SurfaceStyle > > > const & styles) -> Triangulation + """ + this = _ifcopenshell_wrapper.new_Triangulation(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_Triangulation + __del__ = lambda self: None + + def box_project_uvs(vertices, normals): + """box_project_uvs(std::vector< double,std::allocator< double > > const & vertices, std::vector< double,std::allocator< double > > const & normals) -> std::vector< double,std::allocator< double > >""" + return _ifcopenshell_wrapper.Triangulation_box_project_uvs(vertices, normals) + + box_project_uvs = staticmethod(box_project_uvs) + + # Hide the getters with read-only property implementations + id = property(id) + faces = property(faces) + edges = property(edges) + material_ids = property(material_ids) + materials = property(materials) + + + # Hide the getters with read-only property implementations + verts = property(verts) + normals = property(normals) + +Triangulation_swigregister = _ifcopenshell_wrapper.Triangulation_swigregister +Triangulation_swigregister(Triangulation) + +def Triangulation_box_project_uvs(vertices, normals): + """Triangulation_box_project_uvs(std::vector< double,std::allocator< double > > const & vertices, std::vector< double,std::allocator< double > > const & normals) -> std::vector< double,std::allocator< double > >""" + return _ifcopenshell_wrapper.Triangulation_box_project_uvs(vertices, normals) + +class Iterator(_object): + """Proxy of C++ IfcGeom::Iterator class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, Iterator, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, Iterator, name) + __repr__ = _swig_repr + + def __init__(self, *args): + """ + __init__(IfcGeom::Iterator self, IteratorSettings settings, file file, int num_threads=1) -> Iterator + __init__(IfcGeom::Iterator self, IteratorSettings settings, file file) -> Iterator + __init__(IfcGeom::Iterator self, IteratorSettings settings, file file, std::vector< IfcGeom::filter_t,std::allocator< IfcGeom::filter_t > > const & filters, int num_threads=1) -> Iterator + __init__(IfcGeom::Iterator self, IteratorSettings settings, file file, std::vector< IfcGeom::filter_t,std::allocator< IfcGeom::filter_t > > const & filters) -> Iterator + """ + this = _ifcopenshell_wrapper.new_Iterator(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def initialize(self): + """initialize(Iterator self) -> bool""" + return _ifcopenshell_wrapper.Iterator_initialize(self) + + + def progress(self): + """progress(Iterator self) -> int""" + return _ifcopenshell_wrapper.Iterator_progress(self) + + + def compute_bounds(self, with_geometry): + """compute_bounds(Iterator self, bool with_geometry)""" + return _ifcopenshell_wrapper.Iterator_compute_bounds(self, with_geometry) + + + def bounds_min(self): + """bounds_min(Iterator self) -> gp_XYZ const &""" + return _ifcopenshell_wrapper.Iterator_bounds_min(self) + + + def bounds_max(self): + """bounds_max(Iterator self) -> gp_XYZ const &""" + return _ifcopenshell_wrapper.Iterator_bounds_max(self) + + + def unit_name(self): + """unit_name(Iterator self) -> std::string const &""" + return _ifcopenshell_wrapper.Iterator_unit_name(self) + + + def unit_magnitude(self): + """unit_magnitude(Iterator self) -> double""" + return _ifcopenshell_wrapper.Iterator_unit_magnitude(self) + + + def file(self): + """file(Iterator self) -> file""" + return _ifcopenshell_wrapper.Iterator_file(self) + + + def next(self): + """next(Iterator self) -> entity_instance""" + return _ifcopenshell_wrapper.Iterator_next(self) + + + def get(self): + """get(Iterator self) -> Element""" + return _ifcopenshell_wrapper.Iterator_get(self) + + + def get_native(self): + """get_native(Iterator self) -> BRepElement""" + return _ifcopenshell_wrapper.Iterator_get_native(self) + + + def get_object(self, id): + """get_object(Iterator self, int id) -> Element""" + return _ifcopenshell_wrapper.Iterator_get_object(self, id) + + + def create(self): + """create(Iterator self) -> entity_instance""" + return _ifcopenshell_wrapper.Iterator_create(self) + + + def set_cache(self, cache): + """set_cache(Iterator self, GeometrySerializer cache)""" + return _ifcopenshell_wrapper.Iterator_set_cache(self, cache) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_Iterator + __del__ = lambda self: None +Iterator_swigregister = _ifcopenshell_wrapper.Iterator_swigregister +Iterator_swigregister(Iterator) + +class SerializerSettings(IteratorSettings): + """Proxy of C++ SerializerSettings class.""" + + __swig_setmethods__ = {} + for _s in [IteratorSettings]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, SerializerSettings, name, value) + __swig_getmethods__ = {} + for _s in [IteratorSettings]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, SerializerSettings, name) + __repr__ = _swig_repr + USE_ELEMENT_NAMES = _ifcopenshell_wrapper.SerializerSettings_USE_ELEMENT_NAMES + USE_ELEMENT_GUIDS = _ifcopenshell_wrapper.SerializerSettings_USE_ELEMENT_GUIDS + USE_MATERIAL_NAMES = _ifcopenshell_wrapper.SerializerSettings_USE_MATERIAL_NAMES + USE_ELEMENT_TYPES = _ifcopenshell_wrapper.SerializerSettings_USE_ELEMENT_TYPES + USE_ELEMENT_HIERARCHY = _ifcopenshell_wrapper.SerializerSettings_USE_ELEMENT_HIERARCHY + USE_ELEMENT_STEPIDS = _ifcopenshell_wrapper.SerializerSettings_USE_ELEMENT_STEPIDS + USE_Y_UP = _ifcopenshell_wrapper.SerializerSettings_USE_Y_UP + NUM_SETTINGS = _ifcopenshell_wrapper.SerializerSettings_NUM_SETTINGS + + def __init__(self): + """__init__(SerializerSettings self) -> SerializerSettings""" + this = _ifcopenshell_wrapper.new_SerializerSettings() + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_setmethods__["precision"] = _ifcopenshell_wrapper.SerializerSettings_precision_set + __swig_getmethods__["precision"] = _ifcopenshell_wrapper.SerializerSettings_precision_get + if _newclass: + precision = _swig_property(_ifcopenshell_wrapper.SerializerSettings_precision_get, _ifcopenshell_wrapper.SerializerSettings_precision_set) + DEFAULT_PRECISION = _ifcopenshell_wrapper.SerializerSettings_DEFAULT_PRECISION + + + old_init = __init__ + + def __init__(self, **kwargs): + self.old_init() + for k, v in kwargs.items(): + self.set(getattr(self, k), v) + + def __repr__(self): + def d(): + import numbers + for x in dir(self): + if x.isupper() and x not in {"NUM_SETTINGS", "USE_PYTHON_OPENCASCADE", "DEFAULT_PRECISION"}: + v = getattr(self, x) + if isinstance(v, numbers.Integral): + yield x + + return "%s(%s)" % ( + type(self).__name__, + (", ".join(map(lambda x: "%s = %r" % (x, self.get(getattr(self, x))), d()))) + ) + + + __swig_destroy__ = _ifcopenshell_wrapper.delete_SerializerSettings + __del__ = lambda self: None +SerializerSettings_swigregister = _ifcopenshell_wrapper.SerializerSettings_swigregister +SerializerSettings_swigregister(SerializerSettings) + +class buffer(_object): + """Proxy of C++ stream_or_filename class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, buffer, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, buffer, name) + __repr__ = _swig_repr + + def __init__(self, *args): + """ + __init__(stream_or_filename self, std::string const & fn) -> buffer + __init__(stream_or_filename self) -> buffer + """ + this = _ifcopenshell_wrapper.new_buffer(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def get_value(self): + """get_value(buffer self) -> std::string""" + return _ifcopenshell_wrapper.buffer_get_value(self) + + + def filename(self): + """filename(buffer self) -> boost::optional< std::string >""" + return _ifcopenshell_wrapper.buffer_filename(self) + + + def is_ready(self): + """is_ready(buffer self) -> bool""" + return _ifcopenshell_wrapper.buffer_is_ready(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_buffer + __del__ = lambda self: None +buffer_swigregister = _ifcopenshell_wrapper.buffer_swigregister +buffer_swigregister(buffer) + +class GeometrySerializer(_object): + """Proxy of C++ GeometrySerializer class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, GeometrySerializer, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, GeometrySerializer, name) + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + READ_BREP = _ifcopenshell_wrapper.GeometrySerializer_READ_BREP + READ_TRIANGULATION = _ifcopenshell_wrapper.GeometrySerializer_READ_TRIANGULATION + __swig_destroy__ = _ifcopenshell_wrapper.delete_GeometrySerializer + __del__ = lambda self: None + + def isTesselated(self): + """isTesselated(GeometrySerializer self) -> bool""" + return _ifcopenshell_wrapper.GeometrySerializer_isTesselated(self) + + + def write(self, *args): + """ + write(GeometrySerializer self, TriangulationElement o) + write(GeometrySerializer self, BRepElement o) + """ + return _ifcopenshell_wrapper.GeometrySerializer_write(self, *args) + + + def setUnitNameAndMagnitude(self, name, magnitude): + """setUnitNameAndMagnitude(GeometrySerializer self, std::string const & name, float magnitude)""" + return _ifcopenshell_wrapper.GeometrySerializer_setUnitNameAndMagnitude(self, name, magnitude) + + + def read(self, *args): + """ + read(GeometrySerializer self, file f, std::string const & guid, std::string const & representation_id, GeometrySerializer::read_type rt) -> Element + read(GeometrySerializer self, file f, std::string const & guid, std::string const & representation_id) -> Element + """ + return _ifcopenshell_wrapper.GeometrySerializer_read(self, *args) + + + def settings(self, *args): + """ + settings(GeometrySerializer self) -> SerializerSettings + settings(GeometrySerializer self) -> SerializerSettings + """ + return _ifcopenshell_wrapper.GeometrySerializer_settings(self, *args) + + + def object_id(self, o): + """object_id(GeometrySerializer self, Element o) -> std::string""" + return _ifcopenshell_wrapper.GeometrySerializer_object_id(self, o) + +GeometrySerializer_swigregister = _ifcopenshell_wrapper.GeometrySerializer_swigregister +GeometrySerializer_swigregister(GeometrySerializer) + +class WriteOnlyGeometrySerializer(GeometrySerializer): + """Proxy of C++ WriteOnlyGeometrySerializer class.""" + + __swig_setmethods__ = {} + for _s in [GeometrySerializer]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, WriteOnlyGeometrySerializer, name, value) + __swig_getmethods__ = {} + for _s in [GeometrySerializer]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, WriteOnlyGeometrySerializer, name) + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + + def read(self, *args): + """ + read(WriteOnlyGeometrySerializer self, file arg2, std::string const & arg3, std::string const & arg4, GeometrySerializer::read_type arg5) -> Element + read(WriteOnlyGeometrySerializer self, file arg2, std::string const & arg3, std::string const & arg4) -> Element + """ + return _ifcopenshell_wrapper.WriteOnlyGeometrySerializer_read(self, *args) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_WriteOnlyGeometrySerializer + __del__ = lambda self: None +WriteOnlyGeometrySerializer_swigregister = _ifcopenshell_wrapper.WriteOnlyGeometrySerializer_swigregister +WriteOnlyGeometrySerializer_swigregister(WriteOnlyGeometrySerializer) + +class storey_sorter(_object): + """Proxy of C++ storey_sorter class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, storey_sorter, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, storey_sorter, name) + __repr__ = _swig_repr + + def __call__(self, ad, bd): + """__call__(storey_sorter self, drawing_key const & ad, drawing_key const & bd) -> bool""" + return _ifcopenshell_wrapper.storey_sorter___call__(self, ad, bd) + + + def __init__(self): + """__init__(storey_sorter self) -> storey_sorter""" + this = _ifcopenshell_wrapper.new_storey_sorter() + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_storey_sorter + __del__ = lambda self: None +storey_sorter_swigregister = _ifcopenshell_wrapper.storey_sorter_swigregister +storey_sorter_swigregister(storey_sorter) + +class horizontal_plan(_object): + """Proxy of C++ horizontal_plan class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, horizontal_plan, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, horizontal_plan, name) + __repr__ = _swig_repr + __swig_setmethods__["storey"] = _ifcopenshell_wrapper.horizontal_plan_storey_set + __swig_getmethods__["storey"] = _ifcopenshell_wrapper.horizontal_plan_storey_get + if _newclass: + storey = _swig_property(_ifcopenshell_wrapper.horizontal_plan_storey_get, _ifcopenshell_wrapper.horizontal_plan_storey_set) + __swig_setmethods__["elevation"] = _ifcopenshell_wrapper.horizontal_plan_elevation_set + __swig_getmethods__["elevation"] = _ifcopenshell_wrapper.horizontal_plan_elevation_get + if _newclass: + elevation = _swig_property(_ifcopenshell_wrapper.horizontal_plan_elevation_get, _ifcopenshell_wrapper.horizontal_plan_elevation_set) + __swig_setmethods__["offset"] = _ifcopenshell_wrapper.horizontal_plan_offset_set + __swig_getmethods__["offset"] = _ifcopenshell_wrapper.horizontal_plan_offset_get + if _newclass: + offset = _swig_property(_ifcopenshell_wrapper.horizontal_plan_offset_get, _ifcopenshell_wrapper.horizontal_plan_offset_set) + __swig_setmethods__["next_elevation"] = _ifcopenshell_wrapper.horizontal_plan_next_elevation_set + __swig_getmethods__["next_elevation"] = _ifcopenshell_wrapper.horizontal_plan_next_elevation_get + if _newclass: + next_elevation = _swig_property(_ifcopenshell_wrapper.horizontal_plan_next_elevation_get, _ifcopenshell_wrapper.horizontal_plan_next_elevation_set) + + def __init__(self): + """__init__(horizontal_plan self) -> horizontal_plan""" + this = _ifcopenshell_wrapper.new_horizontal_plan() + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_horizontal_plan + __del__ = lambda self: None +horizontal_plan_swigregister = _ifcopenshell_wrapper.horizontal_plan_swigregister +horizontal_plan_swigregister(horizontal_plan) + +class horizontal_plan_at_element(_object): + """Proxy of C++ horizontal_plan_at_element class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, horizontal_plan_at_element, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, horizontal_plan_at_element, name) + __repr__ = _swig_repr + + def __init__(self): + """__init__(horizontal_plan_at_element self) -> horizontal_plan_at_element""" + this = _ifcopenshell_wrapper.new_horizontal_plan_at_element() + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_horizontal_plan_at_element + __del__ = lambda self: None +horizontal_plan_at_element_swigregister = _ifcopenshell_wrapper.horizontal_plan_at_element_swigregister +horizontal_plan_at_element_swigregister(horizontal_plan_at_element) + +class vertical_section(_object): + """Proxy of C++ vertical_section class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, vertical_section, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, vertical_section, name) + __repr__ = _swig_repr + __swig_setmethods__["plane"] = _ifcopenshell_wrapper.vertical_section_plane_set + __swig_getmethods__["plane"] = _ifcopenshell_wrapper.vertical_section_plane_get + if _newclass: + plane = _swig_property(_ifcopenshell_wrapper.vertical_section_plane_get, _ifcopenshell_wrapper.vertical_section_plane_set) + __swig_setmethods__["name"] = _ifcopenshell_wrapper.vertical_section_name_set + __swig_getmethods__["name"] = _ifcopenshell_wrapper.vertical_section_name_get + if _newclass: + name = _swig_property(_ifcopenshell_wrapper.vertical_section_name_get, _ifcopenshell_wrapper.vertical_section_name_set) + __swig_setmethods__["with_projection"] = _ifcopenshell_wrapper.vertical_section_with_projection_set + __swig_getmethods__["with_projection"] = _ifcopenshell_wrapper.vertical_section_with_projection_get + if _newclass: + with_projection = _swig_property(_ifcopenshell_wrapper.vertical_section_with_projection_get, _ifcopenshell_wrapper.vertical_section_with_projection_set) + __swig_setmethods__["scale"] = _ifcopenshell_wrapper.vertical_section_scale_set + __swig_getmethods__["scale"] = _ifcopenshell_wrapper.vertical_section_scale_get + if _newclass: + scale = _swig_property(_ifcopenshell_wrapper.vertical_section_scale_get, _ifcopenshell_wrapper.vertical_section_scale_set) + __swig_setmethods__["size"] = _ifcopenshell_wrapper.vertical_section_size_set + __swig_getmethods__["size"] = _ifcopenshell_wrapper.vertical_section_size_get + if _newclass: + size = _swig_property(_ifcopenshell_wrapper.vertical_section_size_get, _ifcopenshell_wrapper.vertical_section_size_set) + + def __init__(self): + """__init__(vertical_section self) -> vertical_section""" + this = _ifcopenshell_wrapper.new_vertical_section() + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_vertical_section + __del__ = lambda self: None +vertical_section_swigregister = _ifcopenshell_wrapper.vertical_section_swigregister +vertical_section_swigregister(vertical_section) + +class geometry_data(_object): + """Proxy of C++ geometry_data class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, geometry_data, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, geometry_data, name) + __repr__ = _swig_repr + __swig_setmethods__["compound_local"] = _ifcopenshell_wrapper.geometry_data_compound_local_set + __swig_getmethods__["compound_local"] = _ifcopenshell_wrapper.geometry_data_compound_local_get + if _newclass: + compound_local = _swig_property(_ifcopenshell_wrapper.geometry_data_compound_local_get, _ifcopenshell_wrapper.geometry_data_compound_local_set) + __swig_setmethods__["dash_arrays"] = _ifcopenshell_wrapper.geometry_data_dash_arrays_set + __swig_getmethods__["dash_arrays"] = _ifcopenshell_wrapper.geometry_data_dash_arrays_get + if _newclass: + dash_arrays = _swig_property(_ifcopenshell_wrapper.geometry_data_dash_arrays_get, _ifcopenshell_wrapper.geometry_data_dash_arrays_set) + __swig_setmethods__["trsf"] = _ifcopenshell_wrapper.geometry_data_trsf_set + __swig_getmethods__["trsf"] = _ifcopenshell_wrapper.geometry_data_trsf_get + if _newclass: + trsf = _swig_property(_ifcopenshell_wrapper.geometry_data_trsf_get, _ifcopenshell_wrapper.geometry_data_trsf_set) + __swig_setmethods__["product"] = _ifcopenshell_wrapper.geometry_data_product_set + __swig_getmethods__["product"] = _ifcopenshell_wrapper.geometry_data_product_get + if _newclass: + product = _swig_property(_ifcopenshell_wrapper.geometry_data_product_get, _ifcopenshell_wrapper.geometry_data_product_set) + __swig_setmethods__["storey"] = _ifcopenshell_wrapper.geometry_data_storey_set + __swig_getmethods__["storey"] = _ifcopenshell_wrapper.geometry_data_storey_get + if _newclass: + storey = _swig_property(_ifcopenshell_wrapper.geometry_data_storey_get, _ifcopenshell_wrapper.geometry_data_storey_set) + __swig_setmethods__["storey_elevation"] = _ifcopenshell_wrapper.geometry_data_storey_elevation_set + __swig_getmethods__["storey_elevation"] = _ifcopenshell_wrapper.geometry_data_storey_elevation_get + if _newclass: + storey_elevation = _swig_property(_ifcopenshell_wrapper.geometry_data_storey_elevation_get, _ifcopenshell_wrapper.geometry_data_storey_elevation_set) + __swig_setmethods__["ifc_name"] = _ifcopenshell_wrapper.geometry_data_ifc_name_set + __swig_getmethods__["ifc_name"] = _ifcopenshell_wrapper.geometry_data_ifc_name_get + if _newclass: + ifc_name = _swig_property(_ifcopenshell_wrapper.geometry_data_ifc_name_get, _ifcopenshell_wrapper.geometry_data_ifc_name_set) + __swig_setmethods__["svg_name"] = _ifcopenshell_wrapper.geometry_data_svg_name_set + __swig_getmethods__["svg_name"] = _ifcopenshell_wrapper.geometry_data_svg_name_get + if _newclass: + svg_name = _swig_property(_ifcopenshell_wrapper.geometry_data_svg_name_get, _ifcopenshell_wrapper.geometry_data_svg_name_set) + + def __init__(self): + """__init__(geometry_data self) -> geometry_data""" + this = _ifcopenshell_wrapper.new_geometry_data() + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_geometry_data + __del__ = lambda self: None +geometry_data_swigregister = _ifcopenshell_wrapper.geometry_data_swigregister +geometry_data_swigregister(geometry_data) + +class drawing_meta(_object): + """Proxy of C++ drawing_meta class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, drawing_meta, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, drawing_meta, name) + __repr__ = _swig_repr + __swig_setmethods__["pln_3d"] = _ifcopenshell_wrapper.drawing_meta_pln_3d_set + __swig_getmethods__["pln_3d"] = _ifcopenshell_wrapper.drawing_meta_pln_3d_get + if _newclass: + pln_3d = _swig_property(_ifcopenshell_wrapper.drawing_meta_pln_3d_get, _ifcopenshell_wrapper.drawing_meta_pln_3d_set) + __swig_setmethods__["matrix_3"] = _ifcopenshell_wrapper.drawing_meta_matrix_3_set + __swig_getmethods__["matrix_3"] = _ifcopenshell_wrapper.drawing_meta_matrix_3_get + if _newclass: + matrix_3 = _swig_property(_ifcopenshell_wrapper.drawing_meta_matrix_3_get, _ifcopenshell_wrapper.drawing_meta_matrix_3_set) + + def __init__(self): + """__init__(drawing_meta self) -> drawing_meta""" + this = _ifcopenshell_wrapper.new_drawing_meta() + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_drawing_meta + __del__ = lambda self: None +drawing_meta_swigregister = _ifcopenshell_wrapper.drawing_meta_swigregister +drawing_meta_swigregister(drawing_meta) + +ON_SLABS_AT_FLOORPLANS = _ifcopenshell_wrapper.ON_SLABS_AT_FLOORPLANS +ON_SLABS_AND_WALLS = _ifcopenshell_wrapper.ON_SLABS_AND_WALLS +ALWAYS = _ifcopenshell_wrapper.ALWAYS +class SvgSerializer(WriteOnlyGeometrySerializer): + """Proxy of C++ SvgSerializer class.""" + + __swig_setmethods__ = {} + for _s in [WriteOnlyGeometrySerializer]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, SvgSerializer, name, value) + __swig_getmethods__ = {} + for _s in [WriteOnlyGeometrySerializer]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, SvgSerializer, name) + __repr__ = _swig_repr + SH_NONE = _ifcopenshell_wrapper.SvgSerializer_SH_NONE + SH_FULL = _ifcopenshell_wrapper.SvgSerializer_SH_FULL + SH_LEFT = _ifcopenshell_wrapper.SvgSerializer_SH_LEFT + + def __init__(self, out_filename, settings): + """__init__(SvgSerializer self, buffer out_filename, SerializerSettings settings) -> SvgSerializer""" + this = _ifcopenshell_wrapper.new_SvgSerializer(out_filename, settings) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def addXCoordinate(self, fi): + """addXCoordinate(SvgSerializer self, boost::shared_ptr< util::string_buffer::float_item > const & fi)""" + return _ifcopenshell_wrapper.SvgSerializer_addXCoordinate(self, fi) + + + def addYCoordinate(self, fi): + """addYCoordinate(SvgSerializer self, boost::shared_ptr< util::string_buffer::float_item > const & fi)""" + return _ifcopenshell_wrapper.SvgSerializer_addYCoordinate(self, fi) + + + def addSizeComponent(self, fi): + """addSizeComponent(SvgSerializer self, boost::shared_ptr< util::string_buffer::float_item > const & fi)""" + return _ifcopenshell_wrapper.SvgSerializer_addSizeComponent(self, fi) + + + def growBoundingBox(self, x, y): + """growBoundingBox(SvgSerializer self, double x, double y)""" + return _ifcopenshell_wrapper.SvgSerializer_growBoundingBox(self, x, y) + + + def writeHeader(self): + """writeHeader(SvgSerializer self)""" + return _ifcopenshell_wrapper.SvgSerializer_writeHeader(self) + + + def doWriteHeader(self): + """doWriteHeader(SvgSerializer self)""" + return _ifcopenshell_wrapper.SvgSerializer_doWriteHeader(self) + + + def ready(self): + """ready(SvgSerializer self) -> bool""" + return _ifcopenshell_wrapper.SvgSerializer_ready(self) + + + def write(self, *args): + """ + write(SvgSerializer self, TriangulationElement arg2) + write(SvgSerializer self, BRepElement o) + write(SvgSerializer self, SvgSerializer::path_object & p, TopoDS_Shape const & wire, boost::optional< std::vector< double,std::allocator< double > > > dash_array) + write(SvgSerializer self, SvgSerializer::path_object & p, TopoDS_Shape const & wire) + write(SvgSerializer self, geometry_data data) + """ + return _ifcopenshell_wrapper.SvgSerializer_write(self, *args) + + + def start_path(self, *args): + """ + start_path(SvgSerializer self, gp_Pln const & p, IfcBaseEntity storey, std::string const & id) -> SvgSerializer::path_object + start_path(SvgSerializer self, gp_Pln const & p, std::string const & drawing_name, std::string const & id) -> SvgSerializer::path_object & + """ + return _ifcopenshell_wrapper.SvgSerializer_start_path(self, *args) + + + def isTesselated(self): + """isTesselated(SvgSerializer self) -> bool""" + return _ifcopenshell_wrapper.SvgSerializer_isTesselated(self) + + + def finalize(self): + """finalize(SvgSerializer self)""" + return _ifcopenshell_wrapper.SvgSerializer_finalize(self) + + + def setUnitNameAndMagnitude(self, arg2, arg3): + """setUnitNameAndMagnitude(SvgSerializer self, std::string const & arg2, float arg3)""" + return _ifcopenshell_wrapper.SvgSerializer_setUnitNameAndMagnitude(self, arg2, arg3) + + + def setFile(self, f): + """setFile(SvgSerializer self, file f)""" + return _ifcopenshell_wrapper.SvgSerializer_setFile(self, f) + + + def setBoundingRectangle(self, width, height): + """setBoundingRectangle(SvgSerializer self, double width, double height)""" + return _ifcopenshell_wrapper.SvgSerializer_setBoundingRectangle(self, width, height) + + + def setSectionHeight(self, h, storey=None): + """ + setSectionHeight(SvgSerializer self, double h, IfcBaseEntity storey=None) + setSectionHeight(SvgSerializer self, double h) + """ + return _ifcopenshell_wrapper.SvgSerializer_setSectionHeight(self, h, storey) + + + def setSectionHeightsFromStoreys(self, offset=1.2): + """ + setSectionHeightsFromStoreys(SvgSerializer self, double offset=1.2) + setSectionHeightsFromStoreys(SvgSerializer self) + """ + return _ifcopenshell_wrapper.SvgSerializer_setSectionHeightsFromStoreys(self, offset) + + + def setPrintSpaceNames(self, b): + """setPrintSpaceNames(SvgSerializer self, bool b)""" + return _ifcopenshell_wrapper.SvgSerializer_setPrintSpaceNames(self, b) + + + def setPrintSpaceAreas(self, b): + """setPrintSpaceAreas(SvgSerializer self, bool b)""" + return _ifcopenshell_wrapper.SvgSerializer_setPrintSpaceAreas(self, b) + + + def setDrawStoreyHeights(self, sh): + """setDrawStoreyHeights(SvgSerializer self, SvgSerializer::storey_height_display_types sh)""" + return _ifcopenshell_wrapper.SvgSerializer_setDrawStoreyHeights(self, sh) + + + def setDrawDoorArcs(self, b): + """setDrawDoorArcs(SvgSerializer self, bool b)""" + return _ifcopenshell_wrapper.SvgSerializer_setDrawDoorArcs(self, b) + + + def setStoreyHeightLineLength(self, d): + """setStoreyHeightLineLength(SvgSerializer self, double d)""" + return _ifcopenshell_wrapper.SvgSerializer_setStoreyHeightLineLength(self, d) + + + def setSpaceNameTransform(self, v): + """setSpaceNameTransform(SvgSerializer self, std::string const & v)""" + return _ifcopenshell_wrapper.SvgSerializer_setSpaceNameTransform(self, v) + + + def addTextAnnotations(self, k): + """addTextAnnotations(SvgSerializer self, drawing_key const & k)""" + return _ifcopenshell_wrapper.SvgSerializer_addTextAnnotations(self, k) + + + def resize(self): + """resize(SvgSerializer self) -> std::array< std::array< double,3 >,3 >""" + return _ifcopenshell_wrapper.SvgSerializer_resize(self) + + + def resetScale(self): + """resetScale(SvgSerializer self)""" + return _ifcopenshell_wrapper.SvgSerializer_resetScale(self) + + + def setSectionRef(self, s): + """setSectionRef(SvgSerializer self, boost::optional< std::string > const & s)""" + return _ifcopenshell_wrapper.SvgSerializer_setSectionRef(self, s) + + + def setElevationRef(self, s): + """setElevationRef(SvgSerializer self, boost::optional< std::string > const & s)""" + return _ifcopenshell_wrapper.SvgSerializer_setElevationRef(self, s) + + + def setElevationRefGuid(self, s): + """setElevationRefGuid(SvgSerializer self, boost::optional< std::string > const & s)""" + return _ifcopenshell_wrapper.SvgSerializer_setElevationRefGuid(self, s) + + + def setAutoSection(self, b): + """setAutoSection(SvgSerializer self, bool b)""" + return _ifcopenshell_wrapper.SvgSerializer_setAutoSection(self, b) + + + def setAutoElevation(self, b): + """setAutoElevation(SvgSerializer self, bool b)""" + return _ifcopenshell_wrapper.SvgSerializer_setAutoElevation(self, b) + + + def setUseNamespace(self, b): + """setUseNamespace(SvgSerializer self, bool b)""" + return _ifcopenshell_wrapper.SvgSerializer_setUseNamespace(self, b) + + + def setUseHlrPoly(self, b): + """setUseHlrPoly(SvgSerializer self, bool b)""" + return _ifcopenshell_wrapper.SvgSerializer_setUseHlrPoly(self, b) + + + def setPolygonal(self, b): + """setPolygonal(SvgSerializer self, bool b)""" + return _ifcopenshell_wrapper.SvgSerializer_setPolygonal(self, b) + + + def setAlwaysProject(self, b): + """setAlwaysProject(SvgSerializer self, bool b)""" + return _ifcopenshell_wrapper.SvgSerializer_setAlwaysProject(self, b) + + + def setWithoutStoreys(self, b): + """setWithoutStoreys(SvgSerializer self, bool b)""" + return _ifcopenshell_wrapper.SvgSerializer_setWithoutStoreys(self, b) + + + def setNoCSS(self, b): + """setNoCSS(SvgSerializer self, bool b)""" + return _ifcopenshell_wrapper.SvgSerializer_setNoCSS(self, b) + + + def setScale(self, s): + """setScale(SvgSerializer self, double s)""" + return _ifcopenshell_wrapper.SvgSerializer_setScale(self, s) + + + def setDrawingCenter(self, x, y): + """setDrawingCenter(SvgSerializer self, double x, double y)""" + return _ifcopenshell_wrapper.SvgSerializer_setDrawingCenter(self, x, y) + + + def nameElement(self, *args): + """ + nameElement(SvgSerializer self, IfcBaseEntity storey, Element elem) -> std::string + nameElement(SvgSerializer self, IfcBaseEntity elem) -> std::string + """ + return _ifcopenshell_wrapper.SvgSerializer_nameElement(self, *args) + + + def idElement(self, elem): + """idElement(SvgSerializer self, IfcBaseEntity elem) -> std::string""" + return _ifcopenshell_wrapper.SvgSerializer_idElement(self, elem) + + + def object_id(self, storey, o): + """object_id(SvgSerializer self, IfcBaseEntity storey, Element o) -> std::string""" + return _ifcopenshell_wrapper.SvgSerializer_object_id(self, storey, o) + + + def addDrawing(self, pos, dir, ref, name, include_projection): + """addDrawing(SvgSerializer self, gp_Pnt const & pos, gp_Dir const & dir, gp_Dir const & ref, std::string const & name, bool include_projection)""" + return _ifcopenshell_wrapper.SvgSerializer_addDrawing(self, pos, dir, ref, name, include_projection) + + + def setSubtractionSettings(self, sbp): + """setSubtractionSettings(SvgSerializer self, subtract_before_project sbp)""" + return _ifcopenshell_wrapper.SvgSerializer_setSubtractionSettings(self, sbp) + + + def getSubtractionSettings(self): + """getSubtractionSettings(SvgSerializer self) -> subtract_before_project""" + return _ifcopenshell_wrapper.SvgSerializer_getSubtractionSettings(self) + + + def setProfileThreshold(self, i): + """setProfileThreshold(SvgSerializer self, int i)""" + return _ifcopenshell_wrapper.SvgSerializer_setProfileThreshold(self, i) + + + def getProfileThreshold(self): + """getProfileThreshold(SvgSerializer self) -> int""" + return _ifcopenshell_wrapper.SvgSerializer_getProfileThreshold(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_SvgSerializer + __del__ = lambda self: None +SvgSerializer_swigregister = _ifcopenshell_wrapper.SvgSerializer_swigregister +SvgSerializer_swigregister(SvgSerializer) + +class HdfSerializer(GeometrySerializer): + """Proxy of C++ HdfSerializer class.""" + + __swig_setmethods__ = {} + for _s in [GeometrySerializer]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, HdfSerializer, name, value) + __swig_getmethods__ = {} + for _s in [GeometrySerializer]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, HdfSerializer, name) + __repr__ = _swig_repr + + def __init__(self, hdf_filename, settings, read_only=False): + """ + __init__(HdfSerializer self, std::string const & hdf_filename, SerializerSettings settings, bool read_only=False) -> HdfSerializer + __init__(HdfSerializer self, std::string const & hdf_filename, SerializerSettings settings) -> HdfSerializer + """ + this = _ifcopenshell_wrapper.new_HdfSerializer(hdf_filename, settings, read_only) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_HdfSerializer + __del__ = lambda self: None + + def ready(self): + """ready(HdfSerializer self) -> bool""" + return _ifcopenshell_wrapper.HdfSerializer_ready(self) + + + def writeHeader(self): + """writeHeader(HdfSerializer self)""" + return _ifcopenshell_wrapper.HdfSerializer_writeHeader(self) + + + def write(self, *args): + """ + write(HdfSerializer self, Element o) -> H5::Group + write(HdfSerializer self, BRepElement o) + write(HdfSerializer self, TriangulationElement o) + """ + return _ifcopenshell_wrapper.HdfSerializer_write(self, *args) + + + def remove(self, guid): + """remove(HdfSerializer self, std::string const & guid)""" + return _ifcopenshell_wrapper.HdfSerializer_remove(self, guid) + + + def read(self, *args): + """ + read(HdfSerializer self, file f, std::string const & guid, std::string const & arg4, GeometrySerializer::read_type rt) -> Element + read(HdfSerializer self, file f, std::string const & guid, std::string const & arg4) -> Element + """ + return _ifcopenshell_wrapper.HdfSerializer_read(self, *args) + + + def finalize(self): + """finalize(HdfSerializer self)""" + return _ifcopenshell_wrapper.HdfSerializer_finalize(self) + + + def isTesselated(self): + """isTesselated(HdfSerializer self) -> bool""" + return _ifcopenshell_wrapper.HdfSerializer_isTesselated(self) + + + def setUnitNameAndMagnitude(self, arg2, arg3): + """setUnitNameAndMagnitude(HdfSerializer self, std::string const & arg2, float arg3)""" + return _ifcopenshell_wrapper.HdfSerializer_setUnitNameAndMagnitude(self, arg2, arg3) + + + def setFile(self, arg2): + """setFile(HdfSerializer self, file arg2)""" + return _ifcopenshell_wrapper.HdfSerializer_setFile(self, arg2) + +HdfSerializer_swigregister = _ifcopenshell_wrapper.HdfSerializer_swigregister +HdfSerializer_swigregister(HdfSerializer) + +class WaveFrontOBJSerializer(WriteOnlyGeometrySerializer): + """Proxy of C++ WaveFrontOBJSerializer class.""" + + __swig_setmethods__ = {} + for _s in [WriteOnlyGeometrySerializer]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, WaveFrontOBJSerializer, name, value) + __swig_getmethods__ = {} + for _s in [WriteOnlyGeometrySerializer]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, WaveFrontOBJSerializer, name) + __repr__ = _swig_repr + + def __init__(self, obj_filename, mtl_filename, settings): + """__init__(WaveFrontOBJSerializer self, buffer obj_filename, buffer mtl_filename, SerializerSettings settings) -> WaveFrontOBJSerializer""" + this = _ifcopenshell_wrapper.new_WaveFrontOBJSerializer(obj_filename, mtl_filename, settings) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_WaveFrontOBJSerializer + __del__ = lambda self: None + + def ready(self): + """ready(WaveFrontOBJSerializer self) -> bool""" + return _ifcopenshell_wrapper.WaveFrontOBJSerializer_ready(self) + + + def writeHeader(self): + """writeHeader(WaveFrontOBJSerializer self)""" + return _ifcopenshell_wrapper.WaveFrontOBJSerializer_writeHeader(self) + + + def writeMaterial(self, style): + """writeMaterial(WaveFrontOBJSerializer self, Material style)""" + return _ifcopenshell_wrapper.WaveFrontOBJSerializer_writeMaterial(self, style) + + + def write(self, *args): + """ + write(WaveFrontOBJSerializer self, TriangulationElement o) + write(WaveFrontOBJSerializer self, BRepElement arg2) + """ + return _ifcopenshell_wrapper.WaveFrontOBJSerializer_write(self, *args) + + + def finalize(self): + """finalize(WaveFrontOBJSerializer self)""" + return _ifcopenshell_wrapper.WaveFrontOBJSerializer_finalize(self) + + + def isTesselated(self): + """isTesselated(WaveFrontOBJSerializer self) -> bool""" + return _ifcopenshell_wrapper.WaveFrontOBJSerializer_isTesselated(self) + + + def setUnitNameAndMagnitude(self, arg2, arg3): + """setUnitNameAndMagnitude(WaveFrontOBJSerializer self, std::string const & arg2, float arg3)""" + return _ifcopenshell_wrapper.WaveFrontOBJSerializer_setUnitNameAndMagnitude(self, arg2, arg3) + + + def setFile(self, arg2): + """setFile(WaveFrontOBJSerializer self, file arg2)""" + return _ifcopenshell_wrapper.WaveFrontOBJSerializer_setFile(self, arg2) + +WaveFrontOBJSerializer_swigregister = _ifcopenshell_wrapper.WaveFrontOBJSerializer_swigregister +WaveFrontOBJSerializer_swigregister(WaveFrontOBJSerializer) + +class XmlSerializer(_object): + """Proxy of C++ XmlSerializer class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, XmlSerializer, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, XmlSerializer, name) + __repr__ = _swig_repr + + def __init__(self, file, xml_filename): + """__init__(XmlSerializer self, file file, std::string const & xml_filename) -> XmlSerializer""" + this = _ifcopenshell_wrapper.new_XmlSerializer(file, xml_filename) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_XmlSerializer + __del__ = lambda self: None + + def ready(self): + """ready(XmlSerializer self) -> bool""" + return _ifcopenshell_wrapper.XmlSerializer_ready(self) + + + def writeHeader(self): + """writeHeader(XmlSerializer self)""" + return _ifcopenshell_wrapper.XmlSerializer_writeHeader(self) + + + def finalize(self): + """finalize(XmlSerializer self)""" + return _ifcopenshell_wrapper.XmlSerializer_finalize(self) + + + def setFile(self, arg2): + """setFile(XmlSerializer self, file arg2)""" + return _ifcopenshell_wrapper.XmlSerializer_setFile(self, arg2) + +XmlSerializer_swigregister = _ifcopenshell_wrapper.XmlSerializer_swigregister +XmlSerializer_swigregister(XmlSerializer) + +class XmlSerializerFactory(_object): + """Proxy of C++ XmlSerializerFactory class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, XmlSerializerFactory, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, XmlSerializerFactory, name) + __repr__ = _swig_repr + + def implementations(): + """implementations() -> XmlSerializerFactory::Factory &""" + return _ifcopenshell_wrapper.XmlSerializerFactory_implementations() + + implementations = staticmethod(implementations) + + def __init__(self): + """__init__(XmlSerializerFactory self) -> XmlSerializerFactory""" + this = _ifcopenshell_wrapper.new_XmlSerializerFactory() + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_XmlSerializerFactory + __del__ = lambda self: None +XmlSerializerFactory_swigregister = _ifcopenshell_wrapper.XmlSerializerFactory_swigregister +XmlSerializerFactory_swigregister(XmlSerializerFactory) + +def XmlSerializerFactory_implementations(): + """XmlSerializerFactory_implementations() -> XmlSerializerFactory::Factory &""" + return _ifcopenshell_wrapper.XmlSerializerFactory_implementations() + +class GltfSerializer(WriteOnlyGeometrySerializer): + """Proxy of C++ GltfSerializer class.""" + + __swig_setmethods__ = {} + for _s in [WriteOnlyGeometrySerializer]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, GltfSerializer, name, value) + __swig_getmethods__ = {} + for _s in [WriteOnlyGeometrySerializer]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, GltfSerializer, name) + __repr__ = _swig_repr + + def __init__(self, filename, settings): + """__init__(GltfSerializer self, std::string const & filename, SerializerSettings settings) -> GltfSerializer""" + this = _ifcopenshell_wrapper.new_GltfSerializer(filename, settings) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_GltfSerializer + __del__ = lambda self: None + + def ready(self): + """ready(GltfSerializer self) -> bool""" + return _ifcopenshell_wrapper.GltfSerializer_ready(self) + + + def writeHeader(self): + """writeHeader(GltfSerializer self)""" + return _ifcopenshell_wrapper.GltfSerializer_writeHeader(self) + + + def write(self, *args): + """ + write(GltfSerializer self, TriangulationElement o) + write(GltfSerializer self, BRepElement arg2) + """ + return _ifcopenshell_wrapper.GltfSerializer_write(self, *args) + + + def finalize(self): + """finalize(GltfSerializer self)""" + return _ifcopenshell_wrapper.GltfSerializer_finalize(self) + + + def isTesselated(self): + """isTesselated(GltfSerializer self) -> bool""" + return _ifcopenshell_wrapper.GltfSerializer_isTesselated(self) + + + def setUnitNameAndMagnitude(self, arg2, arg3): + """setUnitNameAndMagnitude(GltfSerializer self, std::string const & arg2, float arg3)""" + return _ifcopenshell_wrapper.GltfSerializer_setUnitNameAndMagnitude(self, arg2, arg3) + + + def setFile(self, arg2): + """setFile(GltfSerializer self, file arg2)""" + return _ifcopenshell_wrapper.GltfSerializer_setFile(self, arg2) + +GltfSerializer_swigregister = _ifcopenshell_wrapper.GltfSerializer_swigregister +GltfSerializer_swigregister(GltfSerializer) + +class ray_intersection_results(_object): + """Proxy of C++ std::vector<(IfcGeom::ray_intersection_result)> class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, ray_intersection_results, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, ray_intersection_results, name) + __repr__ = _swig_repr + + def iterator(self): + """iterator(ray_intersection_results self) -> SwigPyIterator""" + return _ifcopenshell_wrapper.ray_intersection_results_iterator(self) + + def __iter__(self): + return self.iterator() + + def __nonzero__(self): + """__nonzero__(ray_intersection_results self) -> bool""" + return _ifcopenshell_wrapper.ray_intersection_results___nonzero__(self) + + + def __bool__(self): + """__bool__(ray_intersection_results self) -> bool""" + return _ifcopenshell_wrapper.ray_intersection_results___bool__(self) + + + def __len__(self): + """__len__(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::size_type""" + return _ifcopenshell_wrapper.ray_intersection_results___len__(self) + + + def __getslice__(self, i, j): + """__getslice__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i, std::vector< IfcGeom::ray_intersection_result >::difference_type j) -> ray_intersection_results""" + return _ifcopenshell_wrapper.ray_intersection_results___getslice__(self, i, j) + + + def __setslice__(self, *args): + """ + __setslice__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i, std::vector< IfcGeom::ray_intersection_result >::difference_type j) + __setslice__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i, std::vector< IfcGeom::ray_intersection_result >::difference_type j, ray_intersection_results v) + """ + return _ifcopenshell_wrapper.ray_intersection_results___setslice__(self, *args) + + + def __delslice__(self, i, j): + """__delslice__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i, std::vector< IfcGeom::ray_intersection_result >::difference_type j)""" + return _ifcopenshell_wrapper.ray_intersection_results___delslice__(self, i, j) + + + def __delitem__(self, *args): + """ + __delitem__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i) + __delitem__(ray_intersection_results self, PySliceObject * slice) + """ + return _ifcopenshell_wrapper.ray_intersection_results___delitem__(self, *args) + + + def __getitem__(self, *args): + """ + __getitem__(ray_intersection_results self, PySliceObject * slice) -> ray_intersection_results + __getitem__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i) -> ray_intersection_result + """ + return _ifcopenshell_wrapper.ray_intersection_results___getitem__(self, *args) + + + def __setitem__(self, *args): + """ + __setitem__(ray_intersection_results self, PySliceObject * slice, ray_intersection_results v) + __setitem__(ray_intersection_results self, PySliceObject * slice) + __setitem__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i, ray_intersection_result x) + """ + return _ifcopenshell_wrapper.ray_intersection_results___setitem__(self, *args) + + + def pop(self): + """pop(ray_intersection_results self) -> ray_intersection_result""" + return _ifcopenshell_wrapper.ray_intersection_results_pop(self) + + + def append(self, x): + """append(ray_intersection_results self, ray_intersection_result x)""" + return _ifcopenshell_wrapper.ray_intersection_results_append(self, x) + + + def empty(self): + """empty(ray_intersection_results self) -> bool""" + return _ifcopenshell_wrapper.ray_intersection_results_empty(self) + + + def size(self): + """size(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::size_type""" + return _ifcopenshell_wrapper.ray_intersection_results_size(self) + + + def swap(self, v): + """swap(ray_intersection_results self, ray_intersection_results v)""" + return _ifcopenshell_wrapper.ray_intersection_results_swap(self, v) + + + def begin(self): + """begin(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::iterator""" + return _ifcopenshell_wrapper.ray_intersection_results_begin(self) + + + def end(self): + """end(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::iterator""" + return _ifcopenshell_wrapper.ray_intersection_results_end(self) + + + def rbegin(self): + """rbegin(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::reverse_iterator""" + return _ifcopenshell_wrapper.ray_intersection_results_rbegin(self) + + + def rend(self): + """rend(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::reverse_iterator""" + return _ifcopenshell_wrapper.ray_intersection_results_rend(self) + + + def clear(self): + """clear(ray_intersection_results self)""" + return _ifcopenshell_wrapper.ray_intersection_results_clear(self) + + + def get_allocator(self): + """get_allocator(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::allocator_type""" + return _ifcopenshell_wrapper.ray_intersection_results_get_allocator(self) + + + def pop_back(self): + """pop_back(ray_intersection_results self)""" + return _ifcopenshell_wrapper.ray_intersection_results_pop_back(self) + + + def erase(self, *args): + """ + erase(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::iterator pos) -> std::vector< IfcGeom::ray_intersection_result >::iterator + erase(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::iterator first, std::vector< IfcGeom::ray_intersection_result >::iterator last) -> std::vector< IfcGeom::ray_intersection_result >::iterator + """ + return _ifcopenshell_wrapper.ray_intersection_results_erase(self, *args) + + + def __init__(self, *args): + """ + __init__(std::vector<(IfcGeom::ray_intersection_result)> self) -> ray_intersection_results + __init__(std::vector<(IfcGeom::ray_intersection_result)> self, ray_intersection_results arg2) -> ray_intersection_results + __init__(std::vector<(IfcGeom::ray_intersection_result)> self, std::vector< IfcGeom::ray_intersection_result >::size_type size) -> ray_intersection_results + __init__(std::vector<(IfcGeom::ray_intersection_result)> self, std::vector< IfcGeom::ray_intersection_result >::size_type size, ray_intersection_result value) -> ray_intersection_results + """ + this = _ifcopenshell_wrapper.new_ray_intersection_results(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def push_back(self, x): + """push_back(ray_intersection_results self, ray_intersection_result x)""" + return _ifcopenshell_wrapper.ray_intersection_results_push_back(self, x) + + + def front(self): + """front(ray_intersection_results self) -> ray_intersection_result""" + return _ifcopenshell_wrapper.ray_intersection_results_front(self) + + + def back(self): + """back(ray_intersection_results self) -> ray_intersection_result""" + return _ifcopenshell_wrapper.ray_intersection_results_back(self) + + + def assign(self, n, x): + """assign(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type n, ray_intersection_result x)""" + return _ifcopenshell_wrapper.ray_intersection_results_assign(self, n, x) + + + def resize(self, *args): + """ + resize(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type new_size) + resize(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type new_size, ray_intersection_result x) + """ + return _ifcopenshell_wrapper.ray_intersection_results_resize(self, *args) + + + def insert(self, *args): + """ + insert(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::iterator pos, ray_intersection_result x) -> std::vector< IfcGeom::ray_intersection_result >::iterator + insert(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::iterator pos, std::vector< IfcGeom::ray_intersection_result >::size_type n, ray_intersection_result x) + """ + return _ifcopenshell_wrapper.ray_intersection_results_insert(self, *args) + + + def reserve(self, n): + """reserve(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type n)""" + return _ifcopenshell_wrapper.ray_intersection_results_reserve(self, n) + + + def capacity(self): + """capacity(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::size_type""" + return _ifcopenshell_wrapper.ray_intersection_results_capacity(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_ray_intersection_results + __del__ = lambda self: None +ray_intersection_results_swigregister = _ifcopenshell_wrapper.ray_intersection_results_swigregister +ray_intersection_results_swigregister(ray_intersection_results) + +class ray_intersection_result(_object): + """Proxy of C++ IfcGeom::ray_intersection_result class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, ray_intersection_result, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, ray_intersection_result, name) + __repr__ = _swig_repr + __swig_setmethods__["distance"] = _ifcopenshell_wrapper.ray_intersection_result_distance_set + __swig_getmethods__["distance"] = _ifcopenshell_wrapper.ray_intersection_result_distance_get + if _newclass: + distance = _swig_property(_ifcopenshell_wrapper.ray_intersection_result_distance_get, _ifcopenshell_wrapper.ray_intersection_result_distance_set) + __swig_setmethods__["style_index"] = _ifcopenshell_wrapper.ray_intersection_result_style_index_set + __swig_getmethods__["style_index"] = _ifcopenshell_wrapper.ray_intersection_result_style_index_get + if _newclass: + style_index = _swig_property(_ifcopenshell_wrapper.ray_intersection_result_style_index_get, _ifcopenshell_wrapper.ray_intersection_result_style_index_set) + __swig_setmethods__["instance"] = _ifcopenshell_wrapper.ray_intersection_result_instance_set + __swig_getmethods__["instance"] = _ifcopenshell_wrapper.ray_intersection_result_instance_get + if _newclass: + instance = _swig_property(_ifcopenshell_wrapper.ray_intersection_result_instance_get, _ifcopenshell_wrapper.ray_intersection_result_instance_set) + __swig_setmethods__["position"] = _ifcopenshell_wrapper.ray_intersection_result_position_set + __swig_getmethods__["position"] = _ifcopenshell_wrapper.ray_intersection_result_position_get + if _newclass: + position = _swig_property(_ifcopenshell_wrapper.ray_intersection_result_position_get, _ifcopenshell_wrapper.ray_intersection_result_position_set) + __swig_setmethods__["normal"] = _ifcopenshell_wrapper.ray_intersection_result_normal_set + __swig_getmethods__["normal"] = _ifcopenshell_wrapper.ray_intersection_result_normal_get + if _newclass: + normal = _swig_property(_ifcopenshell_wrapper.ray_intersection_result_normal_get, _ifcopenshell_wrapper.ray_intersection_result_normal_set) + __swig_setmethods__["ray_distance"] = _ifcopenshell_wrapper.ray_intersection_result_ray_distance_set + __swig_getmethods__["ray_distance"] = _ifcopenshell_wrapper.ray_intersection_result_ray_distance_get + if _newclass: + ray_distance = _swig_property(_ifcopenshell_wrapper.ray_intersection_result_ray_distance_get, _ifcopenshell_wrapper.ray_intersection_result_ray_distance_set) + __swig_setmethods__["dot_product"] = _ifcopenshell_wrapper.ray_intersection_result_dot_product_set + __swig_getmethods__["dot_product"] = _ifcopenshell_wrapper.ray_intersection_result_dot_product_get + if _newclass: + dot_product = _swig_property(_ifcopenshell_wrapper.ray_intersection_result_dot_product_get, _ifcopenshell_wrapper.ray_intersection_result_dot_product_set) + + def __init__(self): + """__init__(IfcGeom::ray_intersection_result self) -> ray_intersection_result""" + this = _ifcopenshell_wrapper.new_ray_intersection_result() + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_ray_intersection_result + __del__ = lambda self: None +ray_intersection_result_swigregister = _ifcopenshell_wrapper.ray_intersection_result_swigregister +ray_intersection_result_swigregister(ray_intersection_result) + +class tree(_object): + """Proxy of C++ IfcGeom::tree class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, tree, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, tree, name) + __repr__ = _swig_repr + + def __init__(self, *args): + """ + __init__(IfcGeom::tree self) -> tree + __init__(IfcGeom::tree self, file f) -> tree + __init__(IfcGeom::tree self, file f, IteratorSettings settings) -> tree + __init__(IfcGeom::tree self, Iterator it) -> tree + """ + this = _ifcopenshell_wrapper.new_tree(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def add_file(self, *args): + """ + add_file(tree self, file f, IteratorSettings settings) + add_file(tree self, Iterator it) + """ + return _ifcopenshell_wrapper.tree_add_file(self, *args) + + + def add_element(self, elem): + """add_element(tree self, BRepElement elem)""" + return _ifcopenshell_wrapper.tree_add_element(self, elem) + + + def distances(self): + """distances(tree self) -> std::vector< double,std::allocator< double > > const &""" + return _ifcopenshell_wrapper.tree_distances(self) + + + def protrusion_distances(self): + """protrusion_distances(tree self) -> std::vector< double,std::allocator< double > > const &""" + return _ifcopenshell_wrapper.tree_protrusion_distances(self) + + + def select_ray(self, p0, d, length=1000.): + """ + select_ray(tree self, gp_Pnt const & p0, gp_Dir const & d, double length=1000.) -> ray_intersection_results + select_ray(tree self, gp_Pnt const & p0, gp_Dir const & d) -> ray_intersection_results + """ + return _ifcopenshell_wrapper.tree_select_ray(self, p0, d, length) + + + def enable_face_styles(self, *args): + """ + enable_face_styles(tree self) -> bool + enable_face_styles(tree self, bool b) + """ + return _ifcopenshell_wrapper.tree_enable_face_styles(self, *args) + + + def styles(self): + """styles(tree self) -> std::vector< IfcGeom::Material,std::allocator< IfcGeom::Material > > const &""" + return _ifcopenshell_wrapper.tree_styles(self) + + + def vector_to_list(ps): + """vector_to_list(std::vector< IfcUtil::IfcBaseEntity *,std::allocator< IfcUtil::IfcBaseEntity * > > const & ps) -> aggregate_of_instance::ptr""" + return _ifcopenshell_wrapper.tree_vector_to_list(ps) + + vector_to_list = staticmethod(vector_to_list) + + def select_box(self, *args): + """ + select_box(tree self, entity_instance e, bool completely_within=False, double extend=-1.e-5) -> aggregate_of_instance::ptr + select_box(tree self, entity_instance e, bool completely_within=False) -> aggregate_of_instance::ptr + select_box(tree self, entity_instance e) -> aggregate_of_instance::ptr + select_box(tree self, gp_Pnt const & p) -> aggregate_of_instance::ptr + select_box(tree self, Bnd_Box const & b, bool completely_within=False) -> aggregate_of_instance::ptr + select_box(tree self, Bnd_Box const & b) -> aggregate_of_instance::ptr + """ + return _ifcopenshell_wrapper.tree_select_box(self, *args) + + + def select(self, *args): + """ + select(tree self, entity_instance e, bool completely_within=False, double extend=0.0) -> aggregate_of_instance::ptr + select(tree self, entity_instance e, bool completely_within=False) -> aggregate_of_instance::ptr + select(tree self, entity_instance e) -> aggregate_of_instance::ptr + select(tree self, gp_Pnt const & p, double extend=0.0) -> aggregate_of_instance::ptr + select(tree self, gp_Pnt const & p) -> aggregate_of_instance::ptr + select(tree self, std::string const & shape_serialization, bool completely_within=False, double extend=-1.e-5) -> aggregate_of_instance::ptr + select(tree self, std::string const & shape_serialization, bool completely_within=False) -> aggregate_of_instance::ptr + select(tree self, std::string const & shape_serialization) -> aggregate_of_instance::ptr + select(tree self, BRepElement elem, bool completely_within=False, double extend=-1.e-5) -> aggregate_of_instance::ptr + select(tree self, BRepElement elem, bool completely_within=False) -> aggregate_of_instance::ptr + select(tree self, BRepElement elem) -> aggregate_of_instance::ptr + """ + return _ifcopenshell_wrapper.tree_select(self, *args) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_tree + __del__ = lambda self: None +tree_swigregister = _ifcopenshell_wrapper.tree_swigregister +tree_swigregister(tree) + +def tree_vector_to_list(ps): + """tree_vector_to_list(std::vector< IfcUtil::IfcBaseEntity *,std::allocator< IfcUtil::IfcBaseEntity * > > const & ps) -> aggregate_of_instance::ptr""" + return _ifcopenshell_wrapper.tree_vector_to_list(ps) + + +def construct_iterator_with_include_exclude(settings, file, elems, include, num_threads): + """construct_iterator_with_include_exclude(IteratorSettings settings, file file, std::vector< std::string,std::allocator< std::string > > elems, bool include, int num_threads) -> Iterator""" + return _ifcopenshell_wrapper.construct_iterator_with_include_exclude(settings, file, elems, include, num_threads) + +def construct_iterator_with_include_exclude_globalid(settings, file, elems, include, num_threads): + """construct_iterator_with_include_exclude_globalid(IteratorSettings settings, file file, std::vector< std::string,std::allocator< std::string > > elems, bool include, int num_threads) -> Iterator""" + return _ifcopenshell_wrapper.construct_iterator_with_include_exclude_globalid(settings, file, elems, include, num_threads) + +def construct_iterator_with_include_exclude_id(settings, file, elems, include, num_threads): + """construct_iterator_with_include_exclude_id(IteratorSettings settings, file file, std::vector< int,std::allocator< int > > elems, bool include, int num_threads) -> Iterator""" + return _ifcopenshell_wrapper.construct_iterator_with_include_exclude_id(settings, file, elems, include, num_threads) + +def create_shape(settings, instance, representation=None): + """ + create_shape(IteratorSettings settings, entity_instance instance, entity_instance representation=None) -> boost::variant< IfcGeom::Element *,IfcGeom::Representation::Representation * > + create_shape(IteratorSettings settings, entity_instance instance) -> boost::variant< IfcGeom::Element *,IfcGeom::Representation::Representation * > + """ + return _ifcopenshell_wrapper.create_shape(settings, instance, representation) + +def serialise(schema_name, shape_str, advanced=True): + """ + serialise(std::string const & schema_name, std::string const & shape_str, bool advanced=True) -> entity_instance + serialise(std::string const & schema_name, std::string const & shape_str) -> entity_instance + """ + return _ifcopenshell_wrapper.serialise(schema_name, shape_str, advanced) + +def tesselate(schema_name, shape_str, d): + """tesselate(std::string const & schema_name, std::string const & shape_str, double d) -> entity_instance""" + return _ifcopenshell_wrapper.tesselate(schema_name, shape_str, d) +class svg_line_segments(_object): + """Proxy of C++ std::vector<(std::array<(svgfill::point_2,2)>)> class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, svg_line_segments, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, svg_line_segments, name) + __repr__ = _swig_repr + + def iterator(self): + """iterator(svg_line_segments self) -> SwigPyIterator""" + return _ifcopenshell_wrapper.svg_line_segments_iterator(self) + + def __iter__(self): + return self.iterator() + + def __nonzero__(self): + """__nonzero__(svg_line_segments self) -> bool""" + return _ifcopenshell_wrapper.svg_line_segments___nonzero__(self) + + + def __bool__(self): + """__bool__(svg_line_segments self) -> bool""" + return _ifcopenshell_wrapper.svg_line_segments___bool__(self) + + + def __len__(self): + """__len__(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::size_type""" + return _ifcopenshell_wrapper.svg_line_segments___len__(self) + + + def __getslice__(self, i, j): + """__getslice__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i, std::vector< std::array< svgfill::point_2,2 > >::difference_type j) -> svg_line_segments""" + return _ifcopenshell_wrapper.svg_line_segments___getslice__(self, i, j) + + + def __setslice__(self, *args): + """ + __setslice__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i, std::vector< std::array< svgfill::point_2,2 > >::difference_type j) + __setslice__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i, std::vector< std::array< svgfill::point_2,2 > >::difference_type j, svg_line_segments v) + """ + return _ifcopenshell_wrapper.svg_line_segments___setslice__(self, *args) + + + def __delslice__(self, i, j): + """__delslice__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i, std::vector< std::array< svgfill::point_2,2 > >::difference_type j)""" + return _ifcopenshell_wrapper.svg_line_segments___delslice__(self, i, j) + + + def __delitem__(self, *args): + """ + __delitem__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i) + __delitem__(svg_line_segments self, PySliceObject * slice) + """ + return _ifcopenshell_wrapper.svg_line_segments___delitem__(self, *args) + + + def __getitem__(self, *args): + """ + __getitem__(svg_line_segments self, PySliceObject * slice) -> svg_line_segments + __getitem__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i) -> line_segment + """ + return _ifcopenshell_wrapper.svg_line_segments___getitem__(self, *args) + + + def __setitem__(self, *args): + """ + __setitem__(svg_line_segments self, PySliceObject * slice, svg_line_segments v) + __setitem__(svg_line_segments self, PySliceObject * slice) + __setitem__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i, line_segment x) + """ + return _ifcopenshell_wrapper.svg_line_segments___setitem__(self, *args) + + + def pop(self): + """pop(svg_line_segments self) -> line_segment""" + return _ifcopenshell_wrapper.svg_line_segments_pop(self) + + + def append(self, x): + """append(svg_line_segments self, line_segment x)""" + return _ifcopenshell_wrapper.svg_line_segments_append(self, x) + + + def empty(self): + """empty(svg_line_segments self) -> bool""" + return _ifcopenshell_wrapper.svg_line_segments_empty(self) + + + def size(self): + """size(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::size_type""" + return _ifcopenshell_wrapper.svg_line_segments_size(self) + + + def swap(self, v): + """swap(svg_line_segments self, svg_line_segments v)""" + return _ifcopenshell_wrapper.svg_line_segments_swap(self, v) + + + def begin(self): + """begin(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::iterator""" + return _ifcopenshell_wrapper.svg_line_segments_begin(self) + + + def end(self): + """end(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::iterator""" + return _ifcopenshell_wrapper.svg_line_segments_end(self) + + + def rbegin(self): + """rbegin(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::reverse_iterator""" + return _ifcopenshell_wrapper.svg_line_segments_rbegin(self) + + + def rend(self): + """rend(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::reverse_iterator""" + return _ifcopenshell_wrapper.svg_line_segments_rend(self) + + + def clear(self): + """clear(svg_line_segments self)""" + return _ifcopenshell_wrapper.svg_line_segments_clear(self) + + + def get_allocator(self): + """get_allocator(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::allocator_type""" + return _ifcopenshell_wrapper.svg_line_segments_get_allocator(self) + + + def pop_back(self): + """pop_back(svg_line_segments self)""" + return _ifcopenshell_wrapper.svg_line_segments_pop_back(self) + + + def erase(self, *args): + """ + erase(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::iterator pos) -> std::vector< std::array< svgfill::point_2,2 > >::iterator + erase(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::iterator first, std::vector< std::array< svgfill::point_2,2 > >::iterator last) -> std::vector< std::array< svgfill::point_2,2 > >::iterator + """ + return _ifcopenshell_wrapper.svg_line_segments_erase(self, *args) + + + def __init__(self, *args): + """ + __init__(std::vector<(std::array<(svgfill::point_2,2)>)> self) -> svg_line_segments + __init__(std::vector<(std::array<(svgfill::point_2,2)>)> self, svg_line_segments arg2) -> svg_line_segments + __init__(std::vector<(std::array<(svgfill::point_2,2)>)> self, std::vector< std::array< svgfill::point_2,2 > >::size_type size) -> svg_line_segments + __init__(std::vector<(std::array<(svgfill::point_2,2)>)> self, std::vector< std::array< svgfill::point_2,2 > >::size_type size, line_segment value) -> svg_line_segments + """ + this = _ifcopenshell_wrapper.new_svg_line_segments(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def push_back(self, x): + """push_back(svg_line_segments self, line_segment x)""" + return _ifcopenshell_wrapper.svg_line_segments_push_back(self, x) + + + def front(self): + """front(svg_line_segments self) -> line_segment""" + return _ifcopenshell_wrapper.svg_line_segments_front(self) + + + def back(self): + """back(svg_line_segments self) -> line_segment""" + return _ifcopenshell_wrapper.svg_line_segments_back(self) + + + def assign(self, n, x): + """assign(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type n, line_segment x)""" + return _ifcopenshell_wrapper.svg_line_segments_assign(self, n, x) + + + def resize(self, *args): + """ + resize(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type new_size) + resize(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type new_size, line_segment x) + """ + return _ifcopenshell_wrapper.svg_line_segments_resize(self, *args) + + + def insert(self, *args): + """ + insert(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::iterator pos, line_segment x) -> std::vector< std::array< svgfill::point_2,2 > >::iterator + insert(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::iterator pos, std::vector< std::array< svgfill::point_2,2 > >::size_type n, line_segment x) + """ + return _ifcopenshell_wrapper.svg_line_segments_insert(self, *args) + + + def reserve(self, n): + """reserve(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type n)""" + return _ifcopenshell_wrapper.svg_line_segments_reserve(self, n) + + + def capacity(self): + """capacity(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::size_type""" + return _ifcopenshell_wrapper.svg_line_segments_capacity(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_line_segments + __del__ = lambda self: None +svg_line_segments_swigregister = _ifcopenshell_wrapper.svg_line_segments_swigregister +svg_line_segments_swigregister(svg_line_segments) + +class svg_groups_of_line_segments(_object): + """Proxy of C++ std::vector<(std::vector<(std::array<(svgfill::point_2,2)>)>)> class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, svg_groups_of_line_segments, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, svg_groups_of_line_segments, name) + __repr__ = _swig_repr + + def iterator(self): + """iterator(svg_groups_of_line_segments self) -> SwigPyIterator""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_iterator(self) + + def __iter__(self): + return self.iterator() + + def __nonzero__(self): + """__nonzero__(svg_groups_of_line_segments self) -> bool""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments___nonzero__(self) + + + def __bool__(self): + """__bool__(svg_groups_of_line_segments self) -> bool""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments___bool__(self) + + + def __len__(self): + """__len__(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments___len__(self) + + + def __getslice__(self, i, j): + """__getslice__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type j) -> svg_groups_of_line_segments""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments___getslice__(self, i, j) + + + def __setslice__(self, *args): + """ + __setslice__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type j) + __setslice__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type j, svg_groups_of_line_segments v) + """ + return _ifcopenshell_wrapper.svg_groups_of_line_segments___setslice__(self, *args) + + + def __delslice__(self, i, j): + """__delslice__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type j)""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments___delslice__(self, i, j) + + + def __delitem__(self, *args): + """ + __delitem__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i) + __delitem__(svg_groups_of_line_segments self, PySliceObject * slice) + """ + return _ifcopenshell_wrapper.svg_groups_of_line_segments___delitem__(self, *args) + + + def __getitem__(self, *args): + """ + __getitem__(svg_groups_of_line_segments self, PySliceObject * slice) -> svg_groups_of_line_segments + __getitem__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i) -> svg_line_segments + """ + return _ifcopenshell_wrapper.svg_groups_of_line_segments___getitem__(self, *args) + + + def __setitem__(self, *args): + """ + __setitem__(svg_groups_of_line_segments self, PySliceObject * slice, svg_groups_of_line_segments v) + __setitem__(svg_groups_of_line_segments self, PySliceObject * slice) + __setitem__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i, svg_line_segments x) + """ + return _ifcopenshell_wrapper.svg_groups_of_line_segments___setitem__(self, *args) + + + def pop(self): + """pop(svg_groups_of_line_segments self) -> svg_line_segments""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_pop(self) + + + def append(self, x): + """append(svg_groups_of_line_segments self, svg_line_segments x)""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_append(self, x) + + + def empty(self): + """empty(svg_groups_of_line_segments self) -> bool""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_empty(self) + + + def size(self): + """size(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_size(self) + + + def swap(self, v): + """swap(svg_groups_of_line_segments self, svg_groups_of_line_segments v)""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_swap(self, v) + + + def begin(self): + """begin(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_begin(self) + + + def end(self): + """end(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_end(self) + + + def rbegin(self): + """rbegin(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::reverse_iterator""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_rbegin(self) + + + def rend(self): + """rend(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::reverse_iterator""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_rend(self) + + + def clear(self): + """clear(svg_groups_of_line_segments self)""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_clear(self) + + + def get_allocator(self): + """get_allocator(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::allocator_type""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_get_allocator(self) + + + def pop_back(self): + """pop_back(svg_groups_of_line_segments self)""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_pop_back(self) + + + def erase(self, *args): + """ + erase(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator pos) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator + erase(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator first, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator last) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator + """ + return _ifcopenshell_wrapper.svg_groups_of_line_segments_erase(self, *args) + + + def __init__(self, *args): + """ + __init__(std::vector<(std::vector<(std::array<(svgfill::point_2,2)>)>)> self) -> svg_groups_of_line_segments + __init__(std::vector<(std::vector<(std::array<(svgfill::point_2,2)>)>)> self, svg_groups_of_line_segments arg2) -> svg_groups_of_line_segments + __init__(std::vector<(std::vector<(std::array<(svgfill::point_2,2)>)>)> self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type size) -> svg_groups_of_line_segments + __init__(std::vector<(std::vector<(std::array<(svgfill::point_2,2)>)>)> self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type size, svg_line_segments value) -> svg_groups_of_line_segments + """ + this = _ifcopenshell_wrapper.new_svg_groups_of_line_segments(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def push_back(self, x): + """push_back(svg_groups_of_line_segments self, svg_line_segments x)""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_push_back(self, x) + + + def front(self): + """front(svg_groups_of_line_segments self) -> svg_line_segments""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_front(self) + + + def back(self): + """back(svg_groups_of_line_segments self) -> svg_line_segments""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_back(self) + + + def assign(self, n, x): + """assign(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type n, svg_line_segments x)""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_assign(self, n, x) + + + def resize(self, *args): + """ + resize(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type new_size) + resize(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type new_size, svg_line_segments x) + """ + return _ifcopenshell_wrapper.svg_groups_of_line_segments_resize(self, *args) + + + def insert(self, *args): + """ + insert(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator pos, svg_line_segments x) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator + insert(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator pos, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type n, svg_line_segments x) + """ + return _ifcopenshell_wrapper.svg_groups_of_line_segments_insert(self, *args) + + + def reserve(self, n): + """reserve(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type n)""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_reserve(self, n) + + + def capacity(self): + """capacity(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type""" + return _ifcopenshell_wrapper.svg_groups_of_line_segments_capacity(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_groups_of_line_segments + __del__ = lambda self: None +svg_groups_of_line_segments_swigregister = _ifcopenshell_wrapper.svg_groups_of_line_segments_swigregister +svg_groups_of_line_segments_swigregister(svg_groups_of_line_segments) + +class svg_point(_object): + """Proxy of C++ std::array<(double,2)> class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, svg_point, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, svg_point, name) + __repr__ = _swig_repr + + def iterator(self): + """iterator(svg_point self) -> SwigPyIterator""" + return _ifcopenshell_wrapper.svg_point_iterator(self) + + def __iter__(self): + return self.iterator() + + def __nonzero__(self): + """__nonzero__(svg_point self) -> bool""" + return _ifcopenshell_wrapper.svg_point___nonzero__(self) + + + def __bool__(self): + """__bool__(svg_point self) -> bool""" + return _ifcopenshell_wrapper.svg_point___bool__(self) + + + def __len__(self): + """__len__(svg_point self) -> std::array< double,2 >::size_type""" + return _ifcopenshell_wrapper.svg_point___len__(self) + + + def __getslice__(self, i, j): + """__getslice__(svg_point self, std::array< double,2 >::difference_type i, std::array< double,2 >::difference_type j) -> svg_point""" + return _ifcopenshell_wrapper.svg_point___getslice__(self, i, j) + + + def __setslice__(self, *args): + """ + __setslice__(svg_point self, std::array< double,2 >::difference_type i, std::array< double,2 >::difference_type j) + __setslice__(svg_point self, std::array< double,2 >::difference_type i, std::array< double,2 >::difference_type j, svg_point v) + """ + return _ifcopenshell_wrapper.svg_point___setslice__(self, *args) + + + def __delslice__(self, i, j): + """__delslice__(svg_point self, std::array< double,2 >::difference_type i, std::array< double,2 >::difference_type j)""" + return _ifcopenshell_wrapper.svg_point___delslice__(self, i, j) + + + def __delitem__(self, *args): + """ + __delitem__(svg_point self, std::array< double,2 >::difference_type i) + __delitem__(svg_point self, PySliceObject * slice) + """ + return _ifcopenshell_wrapper.svg_point___delitem__(self, *args) + + + def __getitem__(self, *args): + """ + __getitem__(svg_point self, PySliceObject * slice) -> svg_point + __getitem__(svg_point self, std::array< double,2 >::difference_type i) -> std::array< double,2 >::value_type const & + """ + return _ifcopenshell_wrapper.svg_point___getitem__(self, *args) + + + def __setitem__(self, *args): + """ + __setitem__(svg_point self, PySliceObject * slice, svg_point v) + __setitem__(svg_point self, PySliceObject * slice) + __setitem__(svg_point self, std::array< double,2 >::difference_type i, std::array< double,2 >::value_type const & x) + """ + return _ifcopenshell_wrapper.svg_point___setitem__(self, *args) + + + def __init__(self, *args): + """ + __init__(std::array<(double,2)> self) -> svg_point + __init__(std::array<(double,2)> self, svg_point arg2) -> svg_point + """ + this = _ifcopenshell_wrapper.new_svg_point(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def empty(self): + """empty(svg_point self) -> bool""" + return _ifcopenshell_wrapper.svg_point_empty(self) + + + def size(self): + """size(svg_point self) -> std::array< double,2 >::size_type""" + return _ifcopenshell_wrapper.svg_point_size(self) + + + def swap(self, v): + """swap(svg_point self, svg_point v)""" + return _ifcopenshell_wrapper.svg_point_swap(self, v) + + + def begin(self): + """begin(svg_point self) -> std::array< double,2 >::iterator""" + return _ifcopenshell_wrapper.svg_point_begin(self) + + + def end(self): + """end(svg_point self) -> std::array< double,2 >::iterator""" + return _ifcopenshell_wrapper.svg_point_end(self) + + + def rbegin(self): + """rbegin(svg_point self) -> std::array< double,2 >::reverse_iterator""" + return _ifcopenshell_wrapper.svg_point_rbegin(self) + + + def rend(self): + """rend(svg_point self) -> std::array< double,2 >::reverse_iterator""" + return _ifcopenshell_wrapper.svg_point_rend(self) + + + def front(self): + """front(svg_point self) -> std::array< double,2 >::value_type const &""" + return _ifcopenshell_wrapper.svg_point_front(self) + + + def back(self): + """back(svg_point self) -> std::array< double,2 >::value_type const &""" + return _ifcopenshell_wrapper.svg_point_back(self) + + + def fill(self, u): + """fill(svg_point self, std::array< double,2 >::value_type const & u)""" + return _ifcopenshell_wrapper.svg_point_fill(self, u) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_point + __del__ = lambda self: None +svg_point_swigregister = _ifcopenshell_wrapper.svg_point_swigregister +svg_point_swigregister(svg_point) + +class line_segment(_object): + """Proxy of C++ std::array<(svgfill::point_2,2)> class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, line_segment, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, line_segment, name) + __repr__ = _swig_repr + + def iterator(self): + """iterator(line_segment self) -> SwigPyIterator""" + return _ifcopenshell_wrapper.line_segment_iterator(self) + + def __iter__(self): + return self.iterator() + + def __nonzero__(self): + """__nonzero__(line_segment self) -> bool""" + return _ifcopenshell_wrapper.line_segment___nonzero__(self) + + + def __bool__(self): + """__bool__(line_segment self) -> bool""" + return _ifcopenshell_wrapper.line_segment___bool__(self) + + + def __len__(self): + """__len__(line_segment self) -> std::array< svgfill::point_2,2 >::size_type""" + return _ifcopenshell_wrapper.line_segment___len__(self) + + + def __getslice__(self, i, j): + """__getslice__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i, std::array< svgfill::point_2,2 >::difference_type j) -> line_segment""" + return _ifcopenshell_wrapper.line_segment___getslice__(self, i, j) + + + def __setslice__(self, *args): + """ + __setslice__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i, std::array< svgfill::point_2,2 >::difference_type j) + __setslice__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i, std::array< svgfill::point_2,2 >::difference_type j, line_segment v) + """ + return _ifcopenshell_wrapper.line_segment___setslice__(self, *args) + + + def __delslice__(self, i, j): + """__delslice__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i, std::array< svgfill::point_2,2 >::difference_type j)""" + return _ifcopenshell_wrapper.line_segment___delslice__(self, i, j) + + + def __delitem__(self, *args): + """ + __delitem__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i) + __delitem__(line_segment self, PySliceObject * slice) + """ + return _ifcopenshell_wrapper.line_segment___delitem__(self, *args) + + + def __getitem__(self, *args): + """ + __getitem__(line_segment self, PySliceObject * slice) -> line_segment + __getitem__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i) -> std::array< svgfill::point_2,2 >::value_type const & + """ + return _ifcopenshell_wrapper.line_segment___getitem__(self, *args) + + + def __setitem__(self, *args): + """ + __setitem__(line_segment self, PySliceObject * slice, line_segment v) + __setitem__(line_segment self, PySliceObject * slice) + __setitem__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i, std::array< svgfill::point_2,2 >::value_type const & x) + """ + return _ifcopenshell_wrapper.line_segment___setitem__(self, *args) + + + def __init__(self, *args): + """ + __init__(std::array<(svgfill::point_2,2)> self) -> line_segment + __init__(std::array<(svgfill::point_2,2)> self, line_segment arg2) -> line_segment + """ + this = _ifcopenshell_wrapper.new_line_segment(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def empty(self): + """empty(line_segment self) -> bool""" + return _ifcopenshell_wrapper.line_segment_empty(self) + + + def size(self): + """size(line_segment self) -> std::array< svgfill::point_2,2 >::size_type""" + return _ifcopenshell_wrapper.line_segment_size(self) + + + def swap(self, v): + """swap(line_segment self, line_segment v)""" + return _ifcopenshell_wrapper.line_segment_swap(self, v) + + + def begin(self): + """begin(line_segment self) -> std::array< svgfill::point_2,2 >::iterator""" + return _ifcopenshell_wrapper.line_segment_begin(self) + + + def end(self): + """end(line_segment self) -> std::array< svgfill::point_2,2 >::iterator""" + return _ifcopenshell_wrapper.line_segment_end(self) + + + def rbegin(self): + """rbegin(line_segment self) -> std::array< svgfill::point_2,2 >::reverse_iterator""" + return _ifcopenshell_wrapper.line_segment_rbegin(self) + + + def rend(self): + """rend(line_segment self) -> std::array< svgfill::point_2,2 >::reverse_iterator""" + return _ifcopenshell_wrapper.line_segment_rend(self) + + + def front(self): + """front(line_segment self) -> std::array< svgfill::point_2,2 >::value_type const &""" + return _ifcopenshell_wrapper.line_segment_front(self) + + + def back(self): + """back(line_segment self) -> std::array< svgfill::point_2,2 >::value_type const &""" + return _ifcopenshell_wrapper.line_segment_back(self) + + + def fill(self, u): + """fill(line_segment self, std::array< svgfill::point_2,2 >::value_type const & u)""" + return _ifcopenshell_wrapper.line_segment_fill(self, u) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_line_segment + __del__ = lambda self: None +line_segment_swigregister = _ifcopenshell_wrapper.line_segment_swigregister +line_segment_swigregister(line_segment) + +class svg_polygons(_object): + """Proxy of C++ std::vector<(svgfill::polygon_2)> class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, svg_polygons, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, svg_polygons, name) + __repr__ = _swig_repr + + def iterator(self): + """iterator(svg_polygons self) -> SwigPyIterator""" + return _ifcopenshell_wrapper.svg_polygons_iterator(self) + + def __iter__(self): + return self.iterator() + + def __nonzero__(self): + """__nonzero__(svg_polygons self) -> bool""" + return _ifcopenshell_wrapper.svg_polygons___nonzero__(self) + + + def __bool__(self): + """__bool__(svg_polygons self) -> bool""" + return _ifcopenshell_wrapper.svg_polygons___bool__(self) + + + def __len__(self): + """__len__(svg_polygons self) -> std::vector< svgfill::polygon_2 >::size_type""" + return _ifcopenshell_wrapper.svg_polygons___len__(self) + + + def __getslice__(self, i, j): + """__getslice__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i, std::vector< svgfill::polygon_2 >::difference_type j) -> svg_polygons""" + return _ifcopenshell_wrapper.svg_polygons___getslice__(self, i, j) + + + def __setslice__(self, *args): + """ + __setslice__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i, std::vector< svgfill::polygon_2 >::difference_type j) + __setslice__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i, std::vector< svgfill::polygon_2 >::difference_type j, svg_polygons v) + """ + return _ifcopenshell_wrapper.svg_polygons___setslice__(self, *args) + + + def __delslice__(self, i, j): + """__delslice__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i, std::vector< svgfill::polygon_2 >::difference_type j)""" + return _ifcopenshell_wrapper.svg_polygons___delslice__(self, i, j) + + + def __delitem__(self, *args): + """ + __delitem__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i) + __delitem__(svg_polygons self, PySliceObject * slice) + """ + return _ifcopenshell_wrapper.svg_polygons___delitem__(self, *args) + + + def __getitem__(self, *args): + """ + __getitem__(svg_polygons self, PySliceObject * slice) -> svg_polygons + __getitem__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i) -> polygon_2 + """ + return _ifcopenshell_wrapper.svg_polygons___getitem__(self, *args) + + + def __setitem__(self, *args): + """ + __setitem__(svg_polygons self, PySliceObject * slice, svg_polygons v) + __setitem__(svg_polygons self, PySliceObject * slice) + __setitem__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i, polygon_2 x) + """ + return _ifcopenshell_wrapper.svg_polygons___setitem__(self, *args) + + + def pop(self): + """pop(svg_polygons self) -> polygon_2""" + return _ifcopenshell_wrapper.svg_polygons_pop(self) + + + def append(self, x): + """append(svg_polygons self, polygon_2 x)""" + return _ifcopenshell_wrapper.svg_polygons_append(self, x) + + + def empty(self): + """empty(svg_polygons self) -> bool""" + return _ifcopenshell_wrapper.svg_polygons_empty(self) + + + def size(self): + """size(svg_polygons self) -> std::vector< svgfill::polygon_2 >::size_type""" + return _ifcopenshell_wrapper.svg_polygons_size(self) + + + def swap(self, v): + """swap(svg_polygons self, svg_polygons v)""" + return _ifcopenshell_wrapper.svg_polygons_swap(self, v) + + + def begin(self): + """begin(svg_polygons self) -> std::vector< svgfill::polygon_2 >::iterator""" + return _ifcopenshell_wrapper.svg_polygons_begin(self) + + + def end(self): + """end(svg_polygons self) -> std::vector< svgfill::polygon_2 >::iterator""" + return _ifcopenshell_wrapper.svg_polygons_end(self) + + + def rbegin(self): + """rbegin(svg_polygons self) -> std::vector< svgfill::polygon_2 >::reverse_iterator""" + return _ifcopenshell_wrapper.svg_polygons_rbegin(self) + + + def rend(self): + """rend(svg_polygons self) -> std::vector< svgfill::polygon_2 >::reverse_iterator""" + return _ifcopenshell_wrapper.svg_polygons_rend(self) + + + def clear(self): + """clear(svg_polygons self)""" + return _ifcopenshell_wrapper.svg_polygons_clear(self) + + + def get_allocator(self): + """get_allocator(svg_polygons self) -> std::vector< svgfill::polygon_2 >::allocator_type""" + return _ifcopenshell_wrapper.svg_polygons_get_allocator(self) + + + def pop_back(self): + """pop_back(svg_polygons self)""" + return _ifcopenshell_wrapper.svg_polygons_pop_back(self) + + + def erase(self, *args): + """ + erase(svg_polygons self, std::vector< svgfill::polygon_2 >::iterator pos) -> std::vector< svgfill::polygon_2 >::iterator + erase(svg_polygons self, std::vector< svgfill::polygon_2 >::iterator first, std::vector< svgfill::polygon_2 >::iterator last) -> std::vector< svgfill::polygon_2 >::iterator + """ + return _ifcopenshell_wrapper.svg_polygons_erase(self, *args) + + + def __init__(self, *args): + """ + __init__(std::vector<(svgfill::polygon_2)> self) -> svg_polygons + __init__(std::vector<(svgfill::polygon_2)> self, svg_polygons arg2) -> svg_polygons + __init__(std::vector<(svgfill::polygon_2)> self, std::vector< svgfill::polygon_2 >::size_type size) -> svg_polygons + __init__(std::vector<(svgfill::polygon_2)> self, std::vector< svgfill::polygon_2 >::size_type size, polygon_2 value) -> svg_polygons + """ + this = _ifcopenshell_wrapper.new_svg_polygons(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def push_back(self, x): + """push_back(svg_polygons self, polygon_2 x)""" + return _ifcopenshell_wrapper.svg_polygons_push_back(self, x) + + + def front(self): + """front(svg_polygons self) -> polygon_2""" + return _ifcopenshell_wrapper.svg_polygons_front(self) + + + def back(self): + """back(svg_polygons self) -> polygon_2""" + return _ifcopenshell_wrapper.svg_polygons_back(self) + + + def assign(self, n, x): + """assign(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type n, polygon_2 x)""" + return _ifcopenshell_wrapper.svg_polygons_assign(self, n, x) + + + def resize(self, *args): + """ + resize(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type new_size) + resize(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type new_size, polygon_2 x) + """ + return _ifcopenshell_wrapper.svg_polygons_resize(self, *args) + + + def insert(self, *args): + """ + insert(svg_polygons self, std::vector< svgfill::polygon_2 >::iterator pos, polygon_2 x) -> std::vector< svgfill::polygon_2 >::iterator + insert(svg_polygons self, std::vector< svgfill::polygon_2 >::iterator pos, std::vector< svgfill::polygon_2 >::size_type n, polygon_2 x) + """ + return _ifcopenshell_wrapper.svg_polygons_insert(self, *args) + + + def reserve(self, n): + """reserve(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type n)""" + return _ifcopenshell_wrapper.svg_polygons_reserve(self, n) + + + def capacity(self): + """capacity(svg_polygons self) -> std::vector< svgfill::polygon_2 >::size_type""" + return _ifcopenshell_wrapper.svg_polygons_capacity(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_polygons + __del__ = lambda self: None +svg_polygons_swigregister = _ifcopenshell_wrapper.svg_polygons_swigregister +svg_polygons_swigregister(svg_polygons) + +class svg_groups_of_polygons(_object): + """Proxy of C++ std::vector<(std::vector<(svgfill::polygon_2)>)> class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, svg_groups_of_polygons, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, svg_groups_of_polygons, name) + __repr__ = _swig_repr + + def iterator(self): + """iterator(svg_groups_of_polygons self) -> SwigPyIterator""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_iterator(self) + + def __iter__(self): + return self.iterator() + + def __nonzero__(self): + """__nonzero__(svg_groups_of_polygons self) -> bool""" + return _ifcopenshell_wrapper.svg_groups_of_polygons___nonzero__(self) + + + def __bool__(self): + """__bool__(svg_groups_of_polygons self) -> bool""" + return _ifcopenshell_wrapper.svg_groups_of_polygons___bool__(self) + + + def __len__(self): + """__len__(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::size_type""" + return _ifcopenshell_wrapper.svg_groups_of_polygons___len__(self) + + + def __getslice__(self, i, j): + """__getslice__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i, std::vector< std::vector< svgfill::polygon_2 > >::difference_type j) -> svg_groups_of_polygons""" + return _ifcopenshell_wrapper.svg_groups_of_polygons___getslice__(self, i, j) + + + def __setslice__(self, *args): + """ + __setslice__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i, std::vector< std::vector< svgfill::polygon_2 > >::difference_type j) + __setslice__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i, std::vector< std::vector< svgfill::polygon_2 > >::difference_type j, svg_groups_of_polygons v) + """ + return _ifcopenshell_wrapper.svg_groups_of_polygons___setslice__(self, *args) + + + def __delslice__(self, i, j): + """__delslice__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i, std::vector< std::vector< svgfill::polygon_2 > >::difference_type j)""" + return _ifcopenshell_wrapper.svg_groups_of_polygons___delslice__(self, i, j) + + + def __delitem__(self, *args): + """ + __delitem__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i) + __delitem__(svg_groups_of_polygons self, PySliceObject * slice) + """ + return _ifcopenshell_wrapper.svg_groups_of_polygons___delitem__(self, *args) + + + def __getitem__(self, *args): + """ + __getitem__(svg_groups_of_polygons self, PySliceObject * slice) -> svg_groups_of_polygons + __getitem__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i) -> svg_polygons + """ + return _ifcopenshell_wrapper.svg_groups_of_polygons___getitem__(self, *args) + + + def __setitem__(self, *args): + """ + __setitem__(svg_groups_of_polygons self, PySliceObject * slice, svg_groups_of_polygons v) + __setitem__(svg_groups_of_polygons self, PySliceObject * slice) + __setitem__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i, svg_polygons x) + """ + return _ifcopenshell_wrapper.svg_groups_of_polygons___setitem__(self, *args) + + + def pop(self): + """pop(svg_groups_of_polygons self) -> svg_polygons""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_pop(self) + + + def append(self, x): + """append(svg_groups_of_polygons self, svg_polygons x)""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_append(self, x) + + + def empty(self): + """empty(svg_groups_of_polygons self) -> bool""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_empty(self) + + + def size(self): + """size(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::size_type""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_size(self) + + + def swap(self, v): + """swap(svg_groups_of_polygons self, svg_groups_of_polygons v)""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_swap(self, v) + + + def begin(self): + """begin(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::iterator""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_begin(self) + + + def end(self): + """end(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::iterator""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_end(self) + + + def rbegin(self): + """rbegin(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::reverse_iterator""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_rbegin(self) + + + def rend(self): + """rend(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::reverse_iterator""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_rend(self) + + + def clear(self): + """clear(svg_groups_of_polygons self)""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_clear(self) + + + def get_allocator(self): + """get_allocator(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::allocator_type""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_get_allocator(self) + + + def pop_back(self): + """pop_back(svg_groups_of_polygons self)""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_pop_back(self) + + + def erase(self, *args): + """ + erase(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::iterator pos) -> std::vector< std::vector< svgfill::polygon_2 > >::iterator + erase(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::iterator first, std::vector< std::vector< svgfill::polygon_2 > >::iterator last) -> std::vector< std::vector< svgfill::polygon_2 > >::iterator + """ + return _ifcopenshell_wrapper.svg_groups_of_polygons_erase(self, *args) + + + def __init__(self, *args): + """ + __init__(std::vector<(std::vector<(svgfill::polygon_2)>)> self) -> svg_groups_of_polygons + __init__(std::vector<(std::vector<(svgfill::polygon_2)>)> self, svg_groups_of_polygons arg2) -> svg_groups_of_polygons + __init__(std::vector<(std::vector<(svgfill::polygon_2)>)> self, std::vector< std::vector< svgfill::polygon_2 > >::size_type size) -> svg_groups_of_polygons + __init__(std::vector<(std::vector<(svgfill::polygon_2)>)> self, std::vector< std::vector< svgfill::polygon_2 > >::size_type size, svg_polygons value) -> svg_groups_of_polygons + """ + this = _ifcopenshell_wrapper.new_svg_groups_of_polygons(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def push_back(self, x): + """push_back(svg_groups_of_polygons self, svg_polygons x)""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_push_back(self, x) + + + def front(self): + """front(svg_groups_of_polygons self) -> svg_polygons""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_front(self) + + + def back(self): + """back(svg_groups_of_polygons self) -> svg_polygons""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_back(self) + + + def assign(self, n, x): + """assign(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type n, svg_polygons x)""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_assign(self, n, x) + + + def resize(self, *args): + """ + resize(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type new_size) + resize(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type new_size, svg_polygons x) + """ + return _ifcopenshell_wrapper.svg_groups_of_polygons_resize(self, *args) + + + def insert(self, *args): + """ + insert(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::iterator pos, svg_polygons x) -> std::vector< std::vector< svgfill::polygon_2 > >::iterator + insert(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::iterator pos, std::vector< std::vector< svgfill::polygon_2 > >::size_type n, svg_polygons x) + """ + return _ifcopenshell_wrapper.svg_groups_of_polygons_insert(self, *args) + + + def reserve(self, n): + """reserve(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type n)""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_reserve(self, n) + + + def capacity(self): + """capacity(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::size_type""" + return _ifcopenshell_wrapper.svg_groups_of_polygons_capacity(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_groups_of_polygons + __del__ = lambda self: None +svg_groups_of_polygons_swigregister = _ifcopenshell_wrapper.svg_groups_of_polygons_swigregister +svg_groups_of_polygons_swigregister(svg_groups_of_polygons) + +class svg_loop(_object): + """Proxy of C++ std::vector<(std::array<(double,2)>)> class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, svg_loop, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, svg_loop, name) + __repr__ = _swig_repr + + def iterator(self): + """iterator(svg_loop self) -> SwigPyIterator""" + return _ifcopenshell_wrapper.svg_loop_iterator(self) + + def __iter__(self): + return self.iterator() + + def __nonzero__(self): + """__nonzero__(svg_loop self) -> bool""" + return _ifcopenshell_wrapper.svg_loop___nonzero__(self) + + + def __bool__(self): + """__bool__(svg_loop self) -> bool""" + return _ifcopenshell_wrapper.svg_loop___bool__(self) + + + def __len__(self): + """__len__(svg_loop self) -> std::vector< std::array< double,2 > >::size_type""" + return _ifcopenshell_wrapper.svg_loop___len__(self) + + + def __getslice__(self, i, j): + """__getslice__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i, std::vector< std::array< double,2 > >::difference_type j) -> svg_loop""" + return _ifcopenshell_wrapper.svg_loop___getslice__(self, i, j) + + + def __setslice__(self, *args): + """ + __setslice__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i, std::vector< std::array< double,2 > >::difference_type j) + __setslice__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i, std::vector< std::array< double,2 > >::difference_type j, svg_loop v) + """ + return _ifcopenshell_wrapper.svg_loop___setslice__(self, *args) + + + def __delslice__(self, i, j): + """__delslice__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i, std::vector< std::array< double,2 > >::difference_type j)""" + return _ifcopenshell_wrapper.svg_loop___delslice__(self, i, j) + + + def __delitem__(self, *args): + """ + __delitem__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i) + __delitem__(svg_loop self, PySliceObject * slice) + """ + return _ifcopenshell_wrapper.svg_loop___delitem__(self, *args) + + + def __getitem__(self, *args): + """ + __getitem__(svg_loop self, PySliceObject * slice) -> svg_loop + __getitem__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i) -> svg_point + """ + return _ifcopenshell_wrapper.svg_loop___getitem__(self, *args) + + + def __setitem__(self, *args): + """ + __setitem__(svg_loop self, PySliceObject * slice, svg_loop v) + __setitem__(svg_loop self, PySliceObject * slice) + __setitem__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i, svg_point x) + """ + return _ifcopenshell_wrapper.svg_loop___setitem__(self, *args) + + + def pop(self): + """pop(svg_loop self) -> svg_point""" + return _ifcopenshell_wrapper.svg_loop_pop(self) + + + def append(self, x): + """append(svg_loop self, svg_point x)""" + return _ifcopenshell_wrapper.svg_loop_append(self, x) + + + def empty(self): + """empty(svg_loop self) -> bool""" + return _ifcopenshell_wrapper.svg_loop_empty(self) + + + def size(self): + """size(svg_loop self) -> std::vector< std::array< double,2 > >::size_type""" + return _ifcopenshell_wrapper.svg_loop_size(self) + + + def swap(self, v): + """swap(svg_loop self, svg_loop v)""" + return _ifcopenshell_wrapper.svg_loop_swap(self, v) + + + def begin(self): + """begin(svg_loop self) -> std::vector< std::array< double,2 > >::iterator""" + return _ifcopenshell_wrapper.svg_loop_begin(self) + + + def end(self): + """end(svg_loop self) -> std::vector< std::array< double,2 > >::iterator""" + return _ifcopenshell_wrapper.svg_loop_end(self) + + + def rbegin(self): + """rbegin(svg_loop self) -> std::vector< std::array< double,2 > >::reverse_iterator""" + return _ifcopenshell_wrapper.svg_loop_rbegin(self) + + + def rend(self): + """rend(svg_loop self) -> std::vector< std::array< double,2 > >::reverse_iterator""" + return _ifcopenshell_wrapper.svg_loop_rend(self) + + + def clear(self): + """clear(svg_loop self)""" + return _ifcopenshell_wrapper.svg_loop_clear(self) + + + def get_allocator(self): + """get_allocator(svg_loop self) -> std::vector< std::array< double,2 > >::allocator_type""" + return _ifcopenshell_wrapper.svg_loop_get_allocator(self) + + + def pop_back(self): + """pop_back(svg_loop self)""" + return _ifcopenshell_wrapper.svg_loop_pop_back(self) + + + def erase(self, *args): + """ + erase(svg_loop self, std::vector< std::array< double,2 > >::iterator pos) -> std::vector< std::array< double,2 > >::iterator + erase(svg_loop self, std::vector< std::array< double,2 > >::iterator first, std::vector< std::array< double,2 > >::iterator last) -> std::vector< std::array< double,2 > >::iterator + """ + return _ifcopenshell_wrapper.svg_loop_erase(self, *args) + + + def __init__(self, *args): + """ + __init__(std::vector<(std::array<(double,2)>)> self) -> svg_loop + __init__(std::vector<(std::array<(double,2)>)> self, svg_loop arg2) -> svg_loop + __init__(std::vector<(std::array<(double,2)>)> self, std::vector< std::array< double,2 > >::size_type size) -> svg_loop + __init__(std::vector<(std::array<(double,2)>)> self, std::vector< std::array< double,2 > >::size_type size, svg_point value) -> svg_loop + """ + this = _ifcopenshell_wrapper.new_svg_loop(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def push_back(self, x): + """push_back(svg_loop self, svg_point x)""" + return _ifcopenshell_wrapper.svg_loop_push_back(self, x) + + + def front(self): + """front(svg_loop self) -> svg_point""" + return _ifcopenshell_wrapper.svg_loop_front(self) + + + def back(self): + """back(svg_loop self) -> svg_point""" + return _ifcopenshell_wrapper.svg_loop_back(self) + + + def assign(self, n, x): + """assign(svg_loop self, std::vector< std::array< double,2 > >::size_type n, svg_point x)""" + return _ifcopenshell_wrapper.svg_loop_assign(self, n, x) + + + def resize(self, *args): + """ + resize(svg_loop self, std::vector< std::array< double,2 > >::size_type new_size) + resize(svg_loop self, std::vector< std::array< double,2 > >::size_type new_size, svg_point x) + """ + return _ifcopenshell_wrapper.svg_loop_resize(self, *args) + + + def insert(self, *args): + """ + insert(svg_loop self, std::vector< std::array< double,2 > >::iterator pos, svg_point x) -> std::vector< std::array< double,2 > >::iterator + insert(svg_loop self, std::vector< std::array< double,2 > >::iterator pos, std::vector< std::array< double,2 > >::size_type n, svg_point x) + """ + return _ifcopenshell_wrapper.svg_loop_insert(self, *args) + + + def reserve(self, n): + """reserve(svg_loop self, std::vector< std::array< double,2 > >::size_type n)""" + return _ifcopenshell_wrapper.svg_loop_reserve(self, n) + + + def capacity(self): + """capacity(svg_loop self) -> std::vector< std::array< double,2 > >::size_type""" + return _ifcopenshell_wrapper.svg_loop_capacity(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_loop + __del__ = lambda self: None +svg_loop_swigregister = _ifcopenshell_wrapper.svg_loop_swigregister +svg_loop_swigregister(svg_loop) + +class svg_loops(_object): + """Proxy of C++ std::vector<(std::vector<(std::array<(double,2)>)>)> class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, svg_loops, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, svg_loops, name) + __repr__ = _swig_repr + + def iterator(self): + """iterator(svg_loops self) -> SwigPyIterator""" + return _ifcopenshell_wrapper.svg_loops_iterator(self) + + def __iter__(self): + return self.iterator() + + def __nonzero__(self): + """__nonzero__(svg_loops self) -> bool""" + return _ifcopenshell_wrapper.svg_loops___nonzero__(self) + + + def __bool__(self): + """__bool__(svg_loops self) -> bool""" + return _ifcopenshell_wrapper.svg_loops___bool__(self) + + + def __len__(self): + """__len__(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::size_type""" + return _ifcopenshell_wrapper.svg_loops___len__(self) + + + def __getslice__(self, i, j): + """__getslice__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i, std::vector< std::vector< std::array< double,2 > > >::difference_type j) -> svg_loops""" + return _ifcopenshell_wrapper.svg_loops___getslice__(self, i, j) + + + def __setslice__(self, *args): + """ + __setslice__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i, std::vector< std::vector< std::array< double,2 > > >::difference_type j) + __setslice__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i, std::vector< std::vector< std::array< double,2 > > >::difference_type j, svg_loops v) + """ + return _ifcopenshell_wrapper.svg_loops___setslice__(self, *args) + + + def __delslice__(self, i, j): + """__delslice__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i, std::vector< std::vector< std::array< double,2 > > >::difference_type j)""" + return _ifcopenshell_wrapper.svg_loops___delslice__(self, i, j) + + + def __delitem__(self, *args): + """ + __delitem__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i) + __delitem__(svg_loops self, PySliceObject * slice) + """ + return _ifcopenshell_wrapper.svg_loops___delitem__(self, *args) + + + def __getitem__(self, *args): + """ + __getitem__(svg_loops self, PySliceObject * slice) -> svg_loops + __getitem__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i) -> svg_loop + """ + return _ifcopenshell_wrapper.svg_loops___getitem__(self, *args) + + + def __setitem__(self, *args): + """ + __setitem__(svg_loops self, PySliceObject * slice, svg_loops v) + __setitem__(svg_loops self, PySliceObject * slice) + __setitem__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i, svg_loop x) + """ + return _ifcopenshell_wrapper.svg_loops___setitem__(self, *args) + + + def pop(self): + """pop(svg_loops self) -> svg_loop""" + return _ifcopenshell_wrapper.svg_loops_pop(self) + + + def append(self, x): + """append(svg_loops self, svg_loop x)""" + return _ifcopenshell_wrapper.svg_loops_append(self, x) + + + def empty(self): + """empty(svg_loops self) -> bool""" + return _ifcopenshell_wrapper.svg_loops_empty(self) + + + def size(self): + """size(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::size_type""" + return _ifcopenshell_wrapper.svg_loops_size(self) + + + def swap(self, v): + """swap(svg_loops self, svg_loops v)""" + return _ifcopenshell_wrapper.svg_loops_swap(self, v) + + + def begin(self): + """begin(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::iterator""" + return _ifcopenshell_wrapper.svg_loops_begin(self) + + + def end(self): + """end(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::iterator""" + return _ifcopenshell_wrapper.svg_loops_end(self) + + + def rbegin(self): + """rbegin(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::reverse_iterator""" + return _ifcopenshell_wrapper.svg_loops_rbegin(self) + + + def rend(self): + """rend(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::reverse_iterator""" + return _ifcopenshell_wrapper.svg_loops_rend(self) + + + def clear(self): + """clear(svg_loops self)""" + return _ifcopenshell_wrapper.svg_loops_clear(self) + + + def get_allocator(self): + """get_allocator(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::allocator_type""" + return _ifcopenshell_wrapper.svg_loops_get_allocator(self) + + + def pop_back(self): + """pop_back(svg_loops self)""" + return _ifcopenshell_wrapper.svg_loops_pop_back(self) + + + def erase(self, *args): + """ + erase(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::iterator pos) -> std::vector< std::vector< std::array< double,2 > > >::iterator + erase(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::iterator first, std::vector< std::vector< std::array< double,2 > > >::iterator last) -> std::vector< std::vector< std::array< double,2 > > >::iterator + """ + return _ifcopenshell_wrapper.svg_loops_erase(self, *args) + + + def __init__(self, *args): + """ + __init__(std::vector<(std::vector<(std::array<(double,2)>)>)> self) -> svg_loops + __init__(std::vector<(std::vector<(std::array<(double,2)>)>)> self, svg_loops arg2) -> svg_loops + __init__(std::vector<(std::vector<(std::array<(double,2)>)>)> self, std::vector< std::vector< std::array< double,2 > > >::size_type size) -> svg_loops + __init__(std::vector<(std::vector<(std::array<(double,2)>)>)> self, std::vector< std::vector< std::array< double,2 > > >::size_type size, svg_loop value) -> svg_loops + """ + this = _ifcopenshell_wrapper.new_svg_loops(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def push_back(self, x): + """push_back(svg_loops self, svg_loop x)""" + return _ifcopenshell_wrapper.svg_loops_push_back(self, x) + + + def front(self): + """front(svg_loops self) -> svg_loop""" + return _ifcopenshell_wrapper.svg_loops_front(self) + + + def back(self): + """back(svg_loops self) -> svg_loop""" + return _ifcopenshell_wrapper.svg_loops_back(self) + + + def assign(self, n, x): + """assign(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type n, svg_loop x)""" + return _ifcopenshell_wrapper.svg_loops_assign(self, n, x) + + + def resize(self, *args): + """ + resize(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type new_size) + resize(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type new_size, svg_loop x) + """ + return _ifcopenshell_wrapper.svg_loops_resize(self, *args) + + + def insert(self, *args): + """ + insert(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::iterator pos, svg_loop x) -> std::vector< std::vector< std::array< double,2 > > >::iterator + insert(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::iterator pos, std::vector< std::vector< std::array< double,2 > > >::size_type n, svg_loop x) + """ + return _ifcopenshell_wrapper.svg_loops_insert(self, *args) + + + def reserve(self, n): + """reserve(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type n)""" + return _ifcopenshell_wrapper.svg_loops_reserve(self, n) + + + def capacity(self): + """capacity(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::size_type""" + return _ifcopenshell_wrapper.svg_loops_capacity(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_loops + __del__ = lambda self: None +svg_loops_swigregister = _ifcopenshell_wrapper.svg_loops_swigregister +svg_loops_swigregister(svg_loops) + +class polygon_2(_object): + """Proxy of C++ svgfill::polygon_2 class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, polygon_2, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, polygon_2, name) + __repr__ = _swig_repr + __swig_setmethods__["boundary"] = _ifcopenshell_wrapper.polygon_2_boundary_set + __swig_getmethods__["boundary"] = _ifcopenshell_wrapper.polygon_2_boundary_get + if _newclass: + boundary = _swig_property(_ifcopenshell_wrapper.polygon_2_boundary_get, _ifcopenshell_wrapper.polygon_2_boundary_set) + __swig_setmethods__["inner_boundaries"] = _ifcopenshell_wrapper.polygon_2_inner_boundaries_set + __swig_getmethods__["inner_boundaries"] = _ifcopenshell_wrapper.polygon_2_inner_boundaries_get + if _newclass: + inner_boundaries = _swig_property(_ifcopenshell_wrapper.polygon_2_inner_boundaries_get, _ifcopenshell_wrapper.polygon_2_inner_boundaries_set) + __swig_setmethods__["point_inside"] = _ifcopenshell_wrapper.polygon_2_point_inside_set + __swig_getmethods__["point_inside"] = _ifcopenshell_wrapper.polygon_2_point_inside_get + if _newclass: + point_inside = _swig_property(_ifcopenshell_wrapper.polygon_2_point_inside_get, _ifcopenshell_wrapper.polygon_2_point_inside_set) + + def __init__(self): + """__init__(svgfill::polygon_2 self) -> polygon_2""" + this = _ifcopenshell_wrapper.new_polygon_2() + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_polygon_2 + __del__ = lambda self: None +polygon_2_swigregister = _ifcopenshell_wrapper.polygon_2_swigregister +polygon_2_swigregister(polygon_2) + +CARTESIAN_DOUBLE = _ifcopenshell_wrapper.CARTESIAN_DOUBLE +CARTESIAN_QUOTIENT = _ifcopenshell_wrapper.CARTESIAN_QUOTIENT +FILTERED_CARTESIAN_QUOTIENT = _ifcopenshell_wrapper.FILTERED_CARTESIAN_QUOTIENT +EXACT_PREDICATES = _ifcopenshell_wrapper.EXACT_PREDICATES +EXACT_CONSTRUCTIONS = _ifcopenshell_wrapper.EXACT_CONSTRUCTIONS +class abstract_arrangement(_object): + """Proxy of C++ svgfill::abstract_arrangement class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, abstract_arrangement, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, abstract_arrangement, name) + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _ifcopenshell_wrapper.delete_abstract_arrangement + __del__ = lambda self: None + + def __call__(self, eps, segments, progress): + """__call__(abstract_arrangement self, double eps, svg_line_segments segments, std::function< void (float) > & progress) -> bool""" + return _ifcopenshell_wrapper.abstract_arrangement___call__(self, eps, segments, progress) + + + def write(self, polygons, progress): + """write(abstract_arrangement self, svg_polygons polygons, std::function< void (float) > & progress) -> bool""" + return _ifcopenshell_wrapper.abstract_arrangement_write(self, polygons, progress) + + + def merge(self, edge_indices): + """merge(abstract_arrangement self, std::vector< int,std::allocator< int > > const & edge_indices)""" + return _ifcopenshell_wrapper.abstract_arrangement_merge(self, edge_indices) + + + def get_face_pairs(self): + """get_face_pairs(abstract_arrangement self) -> std::vector< int,std::allocator< int > >""" + return _ifcopenshell_wrapper.abstract_arrangement_get_face_pairs(self) + + + def num_edges(self): + """num_edges(abstract_arrangement self) -> size_t""" + return _ifcopenshell_wrapper.abstract_arrangement_num_edges(self) + + + def num_faces(self): + """num_faces(abstract_arrangement self) -> size_t""" + return _ifcopenshell_wrapper.abstract_arrangement_num_faces(self) + +abstract_arrangement_swigregister = _ifcopenshell_wrapper.abstract_arrangement_swigregister +abstract_arrangement_swigregister(abstract_arrangement) + +class context(_object): + """Proxy of C++ svgfill::context class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, context, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, context, name) + __repr__ = _swig_repr + + def __init__(self, *args): + """ + __init__(svgfill::context self, svgfill::solver s, double eps) -> context + __init__(svgfill::context self, svgfill::solver s, double eps, std::function< void (float) > & progress) -> context + """ + this = _ifcopenshell_wrapper.new_context(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def add(self, segments): + """add(context self, svg_line_segments segments)""" + return _ifcopenshell_wrapper.context_add(self, segments) + + + def build(self): + """build(context self) -> bool""" + return _ifcopenshell_wrapper.context_build(self) + + + def get_face_pairs(self): + """get_face_pairs(context self) -> std::vector< int,std::allocator< int > >""" + return _ifcopenshell_wrapper.context_get_face_pairs(self) + + + def merge(self, edge_indices): + """merge(context self, std::vector< int,std::allocator< int > > const & edge_indices)""" + return _ifcopenshell_wrapper.context_merge(self, edge_indices) + + + def write(self, arg2): + """write(context self, svg_groups_of_polygons arg2)""" + return _ifcopenshell_wrapper.context_write(self, arg2) + + + def num_edges(self): + """num_edges(context self) -> size_t""" + return _ifcopenshell_wrapper.context_num_edges(self) + + + def num_faces(self): + """num_faces(context self) -> size_t""" + return _ifcopenshell_wrapper.context_num_faces(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_context + __del__ = lambda self: None +context_swigregister = _ifcopenshell_wrapper.context_swigregister +context_swigregister(context) + + +def polygons_to_svg(polygons, random_color=False): + """ + polygons_to_svg(svg_groups_of_polygons polygons, bool random_color=False) -> std::string + polygons_to_svg(svg_groups_of_polygons polygons) -> std::string + """ + return _ifcopenshell_wrapper.polygons_to_svg(polygons, random_color) + +def svg_to_line_segments(data, class_name): + """svg_to_line_segments(std::string const & data, boost::optional< std::string > const & class_name) -> svg_groups_of_line_segments""" + return _ifcopenshell_wrapper.svg_to_line_segments(data, class_name) + +def line_segments_to_polygons(s, eps, segments): + """line_segments_to_polygons(svgfill::solver s, double eps, svg_groups_of_line_segments segments) -> svg_groups_of_polygons""" + return _ifcopenshell_wrapper.line_segments_to_polygons(s, eps, segments) +class IfcEntityInstanceData(_object): + """Proxy of C++ IfcEntityInstanceData class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, IfcEntityInstanceData, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, IfcEntityInstanceData, name) + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined") + __repr__ = _swig_repr + __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcEntityInstanceData + __del__ = lambda self: None +IfcEntityInstanceData_swigregister = _ifcopenshell_wrapper.IfcEntityInstanceData_swigregister +IfcEntityInstanceData_swigregister(IfcEntityInstanceData) + +class HeaderEntity(IfcEntityInstanceData): + """Proxy of C++ IfcParse::HeaderEntity class.""" + + __swig_setmethods__ = {} + for _s in [IfcEntityInstanceData]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, HeaderEntity, name, value) + __swig_getmethods__ = {} + for _s in [IfcEntityInstanceData]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, HeaderEntity, name) + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined") + __repr__ = _swig_repr + + def getArgumentCount(self): + """getArgumentCount(HeaderEntity self) -> size_t""" + return _ifcopenshell_wrapper.HeaderEntity_getArgumentCount(self) + + + def toString(self, upper=False): + """ + toString(HeaderEntity self, bool upper=False) -> std::string + toString(HeaderEntity self) -> std::string + """ + return _ifcopenshell_wrapper.HeaderEntity_toString(self, upper) + +HeaderEntity_swigregister = _ifcopenshell_wrapper.HeaderEntity_swigregister +HeaderEntity_swigregister(HeaderEntity) + +class FileDescription(HeaderEntity): + """Proxy of C++ IfcParse::FileDescription class.""" + + __swig_setmethods__ = {} + for _s in [HeaderEntity]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, FileDescription, name, value) + __swig_getmethods__ = {} + for _s in [HeaderEntity]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, FileDescription, name) + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined") + __repr__ = _swig_repr + + def description(self, *args): + """ + description(FileDescription self) -> std::vector< std::string,std::allocator< std::string > > + description(FileDescription self, std::vector< std::string,std::allocator< std::string > > const & value) + """ + return _ifcopenshell_wrapper.FileDescription_description(self, *args) + + + def implementation_level(self, *args): + """ + implementation_level(FileDescription self) -> std::string + implementation_level(FileDescription self, std::string const & value) + """ + return _ifcopenshell_wrapper.FileDescription_implementation_level(self, *args) + + + # Hide the getters with read-write property implementations + description = property(description, description) + implementation_level = property(implementation_level, implementation_level) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_FileDescription + __del__ = lambda self: None +FileDescription_swigregister = _ifcopenshell_wrapper.FileDescription_swigregister +FileDescription_swigregister(FileDescription) + +class FileName(HeaderEntity): + """Proxy of C++ IfcParse::FileName class.""" + + __swig_setmethods__ = {} + for _s in [HeaderEntity]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, FileName, name, value) + __swig_getmethods__ = {} + for _s in [HeaderEntity]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, FileName, name) + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined") + __repr__ = _swig_repr + + def name(self, *args): + """ + name(FileName self) -> std::string + name(FileName self, std::string const & value) + """ + return _ifcopenshell_wrapper.FileName_name(self, *args) + + + def time_stamp(self, *args): + """ + time_stamp(FileName self) -> std::string + time_stamp(FileName self, std::string const & value) + """ + return _ifcopenshell_wrapper.FileName_time_stamp(self, *args) + + + def author(self, *args): + """ + author(FileName self) -> std::vector< std::string,std::allocator< std::string > > + author(FileName self, std::vector< std::string,std::allocator< std::string > > const & value) + """ + return _ifcopenshell_wrapper.FileName_author(self, *args) + + + def organization(self, *args): + """ + organization(FileName self) -> std::vector< std::string,std::allocator< std::string > > + organization(FileName self, std::vector< std::string,std::allocator< std::string > > const & value) + """ + return _ifcopenshell_wrapper.FileName_organization(self, *args) + + + def preprocessor_version(self, *args): + """ + preprocessor_version(FileName self) -> std::string + preprocessor_version(FileName self, std::string const & value) + """ + return _ifcopenshell_wrapper.FileName_preprocessor_version(self, *args) + + + def originating_system(self, *args): + """ + originating_system(FileName self) -> std::string + originating_system(FileName self, std::string const & value) + """ + return _ifcopenshell_wrapper.FileName_originating_system(self, *args) + + + def authorization(self, *args): + """ + authorization(FileName self) -> std::string + authorization(FileName self, std::string const & value) + """ + return _ifcopenshell_wrapper.FileName_authorization(self, *args) + + + name = property(name, name) + time_stamp = property(time_stamp, time_stamp) + author = property(author, author) + organization = property(organization, organization) + preprocessor_version = property(preprocessor_version, preprocessor_version) + originating_system = property(originating_system, originating_system) + authorization = property(authorization, authorization) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_FileName + __del__ = lambda self: None +FileName_swigregister = _ifcopenshell_wrapper.FileName_swigregister +FileName_swigregister(FileName) + +class FileSchema(HeaderEntity): + """Proxy of C++ IfcParse::FileSchema class.""" + + __swig_setmethods__ = {} + for _s in [HeaderEntity]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, FileSchema, name, value) + __swig_getmethods__ = {} + for _s in [HeaderEntity]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, FileSchema, name) + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined") + __repr__ = _swig_repr + + def schema_identifiers(self, *args): + """ + schema_identifiers(FileSchema self) -> std::vector< std::string,std::allocator< std::string > > + schema_identifiers(FileSchema self, std::vector< std::string,std::allocator< std::string > > const & value) + """ + return _ifcopenshell_wrapper.FileSchema_schema_identifiers(self, *args) + + + # Hide the getters with read-write property implementations + schema_identifiers = property(schema_identifiers, schema_identifiers) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_FileSchema + __del__ = lambda self: None +FileSchema_swigregister = _ifcopenshell_wrapper.FileSchema_swigregister +FileSchema_swigregister(FileSchema) + +class IfcSpfHeader(_object): + """Proxy of C++ IfcParse::IfcSpfHeader class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, IfcSpfHeader, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, IfcSpfHeader, name) + __repr__ = _swig_repr + + def __init__(self, file=None): + """ + __init__(IfcParse::IfcSpfHeader self, file file=None) -> IfcSpfHeader + __init__(IfcParse::IfcSpfHeader self) -> IfcSpfHeader + """ + this = _ifcopenshell_wrapper.new_IfcSpfHeader(file) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcSpfHeader + __del__ = lambda self: None + + def file(self, *args): + """ + file(IfcSpfHeader self) -> file + file(IfcSpfHeader self, file file) + """ + return _ifcopenshell_wrapper.IfcSpfHeader_file(self, *args) + + + def read(self): + """read(IfcSpfHeader self)""" + return _ifcopenshell_wrapper.IfcSpfHeader_read(self) + + + def tryRead(self): + """tryRead(IfcSpfHeader self) -> bool""" + return _ifcopenshell_wrapper.IfcSpfHeader_tryRead(self) + + + def write(self, os): + """write(IfcSpfHeader self, std::ostream & os)""" + return _ifcopenshell_wrapper.IfcSpfHeader_write(self, os) + + + def file_description(self, *args): + """ + file_description(IfcSpfHeader self) -> FileDescription + file_description(IfcSpfHeader self) -> FileDescription + """ + return _ifcopenshell_wrapper.IfcSpfHeader_file_description(self, *args) + + + def file_name(self, *args): + """ + file_name(IfcSpfHeader self) -> FileName + file_name(IfcSpfHeader self) -> FileName + """ + return _ifcopenshell_wrapper.IfcSpfHeader_file_name(self, *args) + + + def file_schema(self, *args): + """ + file_schema(IfcSpfHeader self) -> FileSchema + file_schema(IfcSpfHeader self) -> FileSchema + """ + return _ifcopenshell_wrapper.IfcSpfHeader_file_schema(self, *args) + + + # Hide the getters with read-only property implementations + file_description = property(file_description) + file_name = property(file_name) + file_schema = property(file_schema) + +IfcSpfHeader_swigregister = _ifcopenshell_wrapper.IfcSpfHeader_swigregister +IfcSpfHeader_swigregister(IfcSpfHeader) + +class file_open_status(_object): + """Proxy of C++ IfcParse::file_open_status class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, file_open_status, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, file_open_status, name) + __repr__ = _swig_repr + SUCCESS = _ifcopenshell_wrapper.file_open_status_SUCCESS + READ_ERROR = _ifcopenshell_wrapper.file_open_status_READ_ERROR + NO_HEADER = _ifcopenshell_wrapper.file_open_status_NO_HEADER + UNSUPPORTED_SCHEMA = _ifcopenshell_wrapper.file_open_status_UNSUPPORTED_SCHEMA + + def __init__(self, error): + """__init__(IfcParse::file_open_status self, IfcParse::file_open_status::file_open_enum error) -> file_open_status""" + this = _ifcopenshell_wrapper.new_file_open_status(error) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def value(self): + """value(file_open_status self) -> IfcParse::file_open_status::file_open_enum""" + return _ifcopenshell_wrapper.file_open_status_value(self) + + + def __nonzero__(self): + return _ifcopenshell_wrapper.file_open_status___nonzero__(self) + __bool__ = __nonzero__ + + + __swig_destroy__ = _ifcopenshell_wrapper.delete_file_open_status + __del__ = lambda self: None +file_open_status_swigregister = _ifcopenshell_wrapper.file_open_status_swigregister +file_open_status_swigregister(file_open_status) + +class file(_object): + """Proxy of C++ IfcParse::IfcFile class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, file, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, file, name) + __repr__ = _swig_repr + INSTANCE_ID = _ifcopenshell_wrapper.file_INSTANCE_ID + INSTANCE_TYPE = _ifcopenshell_wrapper.file_INSTANCE_TYPE + ATTRIBUTE_INDEX = _ifcopenshell_wrapper.file_ATTRIBUTE_INDEX + __swig_setmethods__["lazy_load_"] = _ifcopenshell_wrapper.file_lazy_load__set + __swig_getmethods__["lazy_load_"] = _ifcopenshell_wrapper.file_lazy_load__get + if _newclass: + lazy_load_ = _swig_property(_ifcopenshell_wrapper.file_lazy_load__get, _ifcopenshell_wrapper.file_lazy_load__set) + + def lazy_load(*args): + """ + lazy_load() -> bool + lazy_load(bool b) + """ + return _ifcopenshell_wrapper.file_lazy_load(*args) + + lazy_load = staticmethod(lazy_load) + __swig_setmethods__["guid_map_"] = _ifcopenshell_wrapper.file_guid_map__set + __swig_getmethods__["guid_map_"] = _ifcopenshell_wrapper.file_guid_map__get + if _newclass: + guid_map_ = _swig_property(_ifcopenshell_wrapper.file_guid_map__get, _ifcopenshell_wrapper.file_guid_map__set) + + def guid_map(*args): + """ + guid_map() -> bool + guid_map(bool b) + """ + return _ifcopenshell_wrapper.file_guid_map(*args) + + guid_map = staticmethod(guid_map) + __swig_setmethods__["stream"] = _ifcopenshell_wrapper.file_stream_set + __swig_getmethods__["stream"] = _ifcopenshell_wrapper.file_stream_get + if _newclass: + stream = _swig_property(_ifcopenshell_wrapper.file_stream_get, _ifcopenshell_wrapper.file_stream_set) + + def __init__(self, *args): + """ + __init__(IfcParse::IfcFile self, std::string const & fn) -> file + __init__(IfcParse::IfcFile self, std::istream & fn, int len) -> file + __init__(IfcParse::IfcFile self, void * data, int len) -> file + __init__(IfcParse::IfcFile self, IfcParse::IfcSpfStream * f) -> file + __init__(IfcParse::IfcFile self, schema_definition schema) -> file + __init__(IfcParse::IfcFile self) -> file + """ + this = _ifcopenshell_wrapper.new_file(*args) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_file + __del__ = lambda self: None + + def good(self): + """good(file self) -> file_open_status""" + return _ifcopenshell_wrapper.file_good(self) + + + def types_begin(self): + """types_begin(file self) -> IfcParse::IfcFile::type_iterator""" + return _ifcopenshell_wrapper.file_types_begin(self) + + + def types_end(self): + """types_end(file self) -> IfcParse::IfcFile::type_iterator""" + return _ifcopenshell_wrapper.file_types_end(self) + + + def types_incl_super_begin(self): + """types_incl_super_begin(file self) -> IfcParse::IfcFile::type_iterator""" + return _ifcopenshell_wrapper.file_types_incl_super_begin(self) + + + def types_incl_super_end(self): + """types_incl_super_end(file self) -> IfcParse::IfcFile::type_iterator""" + return _ifcopenshell_wrapper.file_types_incl_super_end(self) + + + def by_type(self, *args): + """ + by_type(file self, declaration arg2) -> aggregate_of_instance::ptr + by_type(file self, std::string const & t) -> aggregate_of_instance::ptr + """ + return _ifcopenshell_wrapper.file_by_type(self, *args) + + + def by_type_excl_subtypes(self, *args): + """ + by_type_excl_subtypes(file self, declaration arg2) -> aggregate_of_instance::ptr + by_type_excl_subtypes(file self, std::string const & t) -> aggregate_of_instance::ptr + """ + return _ifcopenshell_wrapper.file_by_type_excl_subtypes(self, *args) + + + def instances_by_reference(self, id): + """instances_by_reference(file self, int id) -> aggregate_of_instance::ptr""" + return _ifcopenshell_wrapper.file_instances_by_reference(self, id) + + + def by_id(self, id): + """by_id(file self, int id) -> entity_instance""" + return _ifcopenshell_wrapper.file_by_id(self, id) + + + def instance_by_guid(self, guid): + """instance_by_guid(file self, std::string const & guid) -> entity_instance""" + return _ifcopenshell_wrapper.file_instance_by_guid(self, guid) + + + def traverse(self, instance, max_level=-1): + """ + traverse(file self, entity_instance instance, int max_level=-1) -> aggregate_of_instance::ptr + traverse(file self, entity_instance instance) -> aggregate_of_instance::ptr + """ + return _ifcopenshell_wrapper.file_traverse(self, instance, max_level) + + + def traverse_breadth_first(self, instance, max_level=-1): + """ + traverse_breadth_first(file self, entity_instance instance, int max_level=-1) -> aggregate_of_instance::ptr + traverse_breadth_first(file self, entity_instance instance) -> aggregate_of_instance::ptr + """ + return _ifcopenshell_wrapper.file_traverse_breadth_first(self, instance, max_level) + + + def getInverse(self, instance_id, type, attribute_index): + """getInverse(file self, int instance_id, declaration type, int attribute_index) -> aggregate_of_instance::ptr""" + return _ifcopenshell_wrapper.file_getInverse(self, instance_id, type, attribute_index) + + + def getTotalInverses(self, instance_id): + """getTotalInverses(file self, int instance_id) -> int""" + return _ifcopenshell_wrapper.file_getTotalInverses(self, instance_id) + + + def FreshId(self): + """FreshId(file self) -> unsigned int""" + return _ifcopenshell_wrapper.file_FreshId(self) + + + def getMaxId(self): + """getMaxId(file self) -> unsigned int""" + return _ifcopenshell_wrapper.file_getMaxId(self) + + + def recalculate_id_counter(self): + """recalculate_id_counter(file self)""" + return _ifcopenshell_wrapper.file_recalculate_id_counter(self) + + + def add(self, entity, id=-1): + """ + add(file self, entity_instance entity, int id=-1) -> entity_instance + add(file self, entity_instance entity) -> entity_instance + """ + return _ifcopenshell_wrapper.file_add(self, entity, id) + + + def addEntities(self, es): + """addEntities(file self, aggregate_of_instance::ptr es)""" + return _ifcopenshell_wrapper.file_addEntities(self, es) + + + def batch(self): + """batch(file self)""" + return _ifcopenshell_wrapper.file_batch(self) + + + def unbatch(self): + """unbatch(file self)""" + return _ifcopenshell_wrapper.file_unbatch(self) + + + def remove(self, entity): + """remove(file self, entity_instance entity)""" + return _ifcopenshell_wrapper.file_remove(self, entity) + + + def header(self, *args): + """ + header(file self) -> IfcSpfHeader + header(file self) -> IfcSpfHeader + """ + return _ifcopenshell_wrapper.file_header(self, *args) + + + def createTimestamp(self): + """createTimestamp(file self) -> std::string""" + return _ifcopenshell_wrapper.file_createTimestamp(self) + + + def load(self, entity_instance_name, entity, attributes, num_attributes, attribute_index=-1): + """ + load(file self, unsigned int entity_instance_name, entity entity, Argument **& attributes, size_t num_attributes, int attribute_index=-1) -> size_t + load(file self, unsigned int entity_instance_name, entity entity, Argument **& attributes, size_t num_attributes) -> size_t + """ + return _ifcopenshell_wrapper.file_load(self, entity_instance_name, entity, attributes, num_attributes, attribute_index) + + + def seek_to(self, data): + """seek_to(file self, IfcEntityInstanceData data)""" + return _ifcopenshell_wrapper.file_seek_to(self, data) + + + def try_read_semicolon(self): + """try_read_semicolon(file self)""" + return _ifcopenshell_wrapper.file_try_read_semicolon(self) + + + def getUnit(self, unit_type): + """getUnit(file self, std::string const & unit_type) -> std::pair< IfcUtil::IfcBaseClass *,double >""" + return _ifcopenshell_wrapper.file_getUnit(self, unit_type) + + + def parsing_complete(self, *args): + """ + parsing_complete(file self) -> bool + parsing_complete(file self) -> bool & + """ + return _ifcopenshell_wrapper.file_parsing_complete(self, *args) + + + def build_inverses(self): + """build_inverses(file self)""" + return _ifcopenshell_wrapper.file_build_inverses(self) + + + def by_guid(self, guid): + """by_guid(file self, std::string const & guid) -> entity_instance""" + return _ifcopenshell_wrapper.file_by_guid(self, guid) + + + def get_inverse(self, e): + """get_inverse(file self, entity_instance e) -> aggregate_of_instance::ptr""" + return _ifcopenshell_wrapper.file_get_inverse(self, e) + + + def get_total_inverses(self, e): + """get_total_inverses(file self, entity_instance e) -> int""" + return _ifcopenshell_wrapper.file_get_total_inverses(self, e) + + + def write(self, fn): + """write(file self, std::string const & fn)""" + return _ifcopenshell_wrapper.file_write(self, fn) + + + def to_string(self): + """to_string(file self) -> std::string""" + return _ifcopenshell_wrapper.file_to_string(self) + + + def entity_names(self): + """entity_names(file self) -> std::vector< unsigned int,std::allocator< unsigned int > >""" + return _ifcopenshell_wrapper.file_entity_names(self) + + + def types(self): + """types(file self) -> std::vector< std::string,std::allocator< std::string > >""" + return _ifcopenshell_wrapper.file_types(self) + + + def types_with_super(self): + """types_with_super(file self) -> std::vector< std::string,std::allocator< std::string > >""" + return _ifcopenshell_wrapper.file_types_with_super(self) + + + def schema_name(self): + """schema_name(file self) -> std::string""" + return _ifcopenshell_wrapper.file_schema_name(self) + + + # Hide the getters with read-only property implementations + header = property(header) + schema = property(schema_name) + +file_swigregister = _ifcopenshell_wrapper.file_swigregister +file_swigregister(file) +cvar = _ifcopenshell_wrapper.cvar + +def file_lazy_load(*args): + """ + lazy_load() -> bool + file_lazy_load(bool b) + """ + return _ifcopenshell_wrapper.file_lazy_load(*args) + +def file_guid_map(*args): + """ + guid_map() -> bool + file_guid_map(bool b) + """ + return _ifcopenshell_wrapper.file_guid_map(*args) + + +def parse_ifcxml(filename): + """parse_ifcxml(std::string const & filename) -> file""" + return _ifcopenshell_wrapper.parse_ifcxml(filename) +class IfcBaseInterface(_object): + """Proxy of C++ IfcUtil::IfcBaseInterface class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, IfcBaseInterface, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, IfcBaseInterface, name) + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + + def data(self, *args): + """ + data(IfcBaseInterface self) -> IfcEntityInstanceData + data(IfcBaseInterface self) -> IfcEntityInstanceData + """ + return _ifcopenshell_wrapper.IfcBaseInterface_data(self, *args) + + + def declaration(self): + """declaration(IfcBaseInterface self) -> declaration""" + return _ifcopenshell_wrapper.IfcBaseInterface_declaration(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcBaseInterface + __del__ = lambda self: None +IfcBaseInterface_swigregister = _ifcopenshell_wrapper.IfcBaseInterface_swigregister +IfcBaseInterface_swigregister(IfcBaseInterface) + +class entity_instance(IfcBaseInterface): + """Proxy of C++ IfcUtil::IfcBaseClass class.""" + + __swig_setmethods__ = {} + for _s in [IfcBaseInterface]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, entity_instance, name, value) + __swig_getmethods__ = {} + for _s in [IfcBaseInterface]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, entity_instance, name) + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __swig_destroy__ = _ifcopenshell_wrapper.delete_entity_instance + __del__ = lambda self: None + + def data(self, *args): + """ + data(entity_instance self) -> IfcEntityInstanceData + data(entity_instance self) -> IfcEntityInstanceData + data(entity_instance self, IfcEntityInstanceData d) + """ + return _ifcopenshell_wrapper.entity_instance_data(self, *args) + + + def declaration(self): + """declaration(entity_instance self) -> declaration""" + return _ifcopenshell_wrapper.entity_instance_declaration(self) + + + def identity(self): + """identity(entity_instance self) -> uint32_t""" + return _ifcopenshell_wrapper.entity_instance_identity(self) + + + def get_attribute_category(self, name): + """get_attribute_category(entity_instance self, std::string const & name) -> int""" + return _ifcopenshell_wrapper.entity_instance_get_attribute_category(self, name) + + + def id(self): + """id(entity_instance self) -> int""" + return _ifcopenshell_wrapper.entity_instance_id(self) + + + def __len__(self): + """__len__(entity_instance self) -> int""" + return _ifcopenshell_wrapper.entity_instance___len__(self) + + + def get_attribute_names(self): + """get_attribute_names(entity_instance self) -> std::vector< std::string,std::allocator< std::string > >""" + return _ifcopenshell_wrapper.entity_instance_get_attribute_names(self) + + + def get_inverse_attribute_names(self): + """get_inverse_attribute_names(entity_instance self) -> std::vector< std::string,std::allocator< std::string > >""" + return _ifcopenshell_wrapper.entity_instance_get_inverse_attribute_names(self) + + + def is_a(self, *args): + """ + is_a(entity_instance self, std::string const & s) -> bool + is_a(entity_instance self, bool with_schema=False) -> std::string + is_a(entity_instance self) -> std::string + """ + return _ifcopenshell_wrapper.entity_instance_is_a(self, *args) + + + def get_argument(self, *args): + """ + get_argument(entity_instance self, unsigned int i) -> std::pair< IfcUtil::ArgumentType,Argument * > + get_argument(entity_instance self, std::string const & a) -> std::pair< IfcUtil::ArgumentType,Argument * > + """ + return _ifcopenshell_wrapper.entity_instance_get_argument(self, *args) + + + def __eq__(self, other): + """__eq__(entity_instance self, entity_instance other) -> bool""" + return _ifcopenshell_wrapper.entity_instance___eq__(self, other) + + + def __repr__(self): + """__repr__(entity_instance self) -> std::string""" + return _ifcopenshell_wrapper.entity_instance___repr__(self) + + + def file_pointer(self): + """file_pointer(entity_instance self) -> size_t""" + return _ifcopenshell_wrapper.entity_instance_file_pointer(self) + + + def get_argument_index(self, a): + """get_argument_index(entity_instance self, std::string const & a) -> unsigned int""" + return _ifcopenshell_wrapper.entity_instance_get_argument_index(self, a) + + + def get_inverse(self, a): + """get_inverse(entity_instance self, std::string const & a) -> aggregate_of_instance::ptr""" + return _ifcopenshell_wrapper.entity_instance_get_inverse(self, a) + + + def get_argument_type(self, i): + """get_argument_type(entity_instance self, unsigned int i) -> char const *const""" + return _ifcopenshell_wrapper.entity_instance_get_argument_type(self, i) + + + def get_argument_name(self, i): + """get_argument_name(entity_instance self, unsigned int i) -> std::string const &""" + return _ifcopenshell_wrapper.entity_instance_get_argument_name(self, i) + + + def setArgumentAsNull(self, i): + """setArgumentAsNull(entity_instance self, unsigned int i)""" + return _ifcopenshell_wrapper.entity_instance_setArgumentAsNull(self, i) + + + def setArgumentAsInt(self, i, v): + """setArgumentAsInt(entity_instance self, unsigned int i, int v)""" + return _ifcopenshell_wrapper.entity_instance_setArgumentAsInt(self, i, v) + + + def setArgumentAsBool(self, i, v): + """setArgumentAsBool(entity_instance self, unsigned int i, bool v)""" + return _ifcopenshell_wrapper.entity_instance_setArgumentAsBool(self, i, v) + + + def setArgumentAsLogical(self, i, v): + """setArgumentAsLogical(entity_instance self, unsigned int i, boost::logic::tribool v)""" + return _ifcopenshell_wrapper.entity_instance_setArgumentAsLogical(self, i, v) + + + def setArgumentAsDouble(self, i, v): + """setArgumentAsDouble(entity_instance self, unsigned int i, double v)""" + return _ifcopenshell_wrapper.entity_instance_setArgumentAsDouble(self, i, v) + + + def setArgumentAsString(self, i, a): + """setArgumentAsString(entity_instance self, unsigned int i, std::string const & a)""" + return _ifcopenshell_wrapper.entity_instance_setArgumentAsString(self, i, a) + + + def setArgumentAsAggregateOfInt(self, i, v): + """setArgumentAsAggregateOfInt(entity_instance self, unsigned int i, std::vector< int,std::allocator< int > > const & v)""" + return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfInt(self, i, v) + + + def setArgumentAsAggregateOfDouble(self, i, v): + """setArgumentAsAggregateOfDouble(entity_instance self, unsigned int i, std::vector< double,std::allocator< double > > const & v)""" + return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfDouble(self, i, v) + + + def setArgumentAsAggregateOfString(self, i, v): + """setArgumentAsAggregateOfString(entity_instance self, unsigned int i, std::vector< std::string,std::allocator< std::string > > const & v)""" + return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfString(self, i, v) + + + def setArgumentAsEntityInstance(self, i, v): + """setArgumentAsEntityInstance(entity_instance self, unsigned int i, entity_instance v)""" + return _ifcopenshell_wrapper.entity_instance_setArgumentAsEntityInstance(self, i, v) + + + def setArgumentAsAggregateOfEntityInstance(self, i, v): + """setArgumentAsAggregateOfEntityInstance(entity_instance self, unsigned int i, aggregate_of_instance::ptr v)""" + return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfEntityInstance(self, i, v) + + + def setArgumentAsAggregateOfAggregateOfInt(self, i, v): + """setArgumentAsAggregateOfAggregateOfInt(entity_instance self, unsigned int i, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & v)""" + return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfAggregateOfInt(self, i, v) + + + def setArgumentAsAggregateOfAggregateOfDouble(self, i, v): + """setArgumentAsAggregateOfAggregateOfDouble(entity_instance self, unsigned int i, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const & v)""" + return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfAggregateOfDouble(self, i, v) + + + def setArgumentAsAggregateOfAggregateOfEntityInstance(self, i, v): + """setArgumentAsAggregateOfAggregateOfEntityInstance(entity_instance self, unsigned int i, aggregate_of_aggregate_of_instance::ptr v)""" + return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfAggregateOfEntityInstance(self, i, v) + +entity_instance_swigregister = _ifcopenshell_wrapper.entity_instance_swigregister +entity_instance_swigregister(entity_instance) + +class IfcLateBoundEntity(entity_instance): + """Proxy of C++ IfcUtil::IfcLateBoundEntity class.""" + + __swig_setmethods__ = {} + for _s in [entity_instance]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, IfcLateBoundEntity, name, value) + __swig_getmethods__ = {} + for _s in [entity_instance]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, IfcLateBoundEntity, name) + __repr__ = _swig_repr + + def __init__(self, decl, data): + """__init__(IfcUtil::IfcLateBoundEntity self, declaration decl, IfcEntityInstanceData data) -> IfcLateBoundEntity""" + this = _ifcopenshell_wrapper.new_IfcLateBoundEntity(decl, data) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def declaration(self): + """declaration(IfcLateBoundEntity self) -> declaration""" + return _ifcopenshell_wrapper.IfcLateBoundEntity_declaration(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcLateBoundEntity + __del__ = lambda self: None +IfcLateBoundEntity_swigregister = _ifcopenshell_wrapper.IfcLateBoundEntity_swigregister +IfcLateBoundEntity_swigregister(IfcLateBoundEntity) + +class IfcBaseEntity(entity_instance): + """Proxy of C++ IfcUtil::IfcBaseEntity class.""" + + __swig_setmethods__ = {} + for _s in [entity_instance]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, IfcBaseEntity, name, value) + __swig_getmethods__ = {} + for _s in [entity_instance]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, IfcBaseEntity, name) + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + + def declaration(self): + """declaration(IfcBaseEntity self) -> entity""" + return _ifcopenshell_wrapper.IfcBaseEntity_declaration(self) + + + def get(self, name): + """get(IfcBaseEntity self, std::string const & name) -> Argument *""" + return _ifcopenshell_wrapper.IfcBaseEntity_get(self, name) + + + def get_inverse(self, a): + """get_inverse(IfcBaseEntity self, std::string const & a) -> boost::shared_ptr< aggregate_of_instance >""" + return _ifcopenshell_wrapper.IfcBaseEntity_get_inverse(self, a) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcBaseEntity + __del__ = lambda self: None +IfcBaseEntity_swigregister = _ifcopenshell_wrapper.IfcBaseEntity_swigregister +IfcBaseEntity_swigregister(IfcBaseEntity) + +class IfcBaseType(entity_instance): + """Proxy of C++ IfcUtil::IfcBaseType class.""" + + __swig_setmethods__ = {} + for _s in [entity_instance]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, IfcBaseType, name, value) + __swig_getmethods__ = {} + for _s in [entity_instance]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, IfcBaseType, name) + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + + def declaration(self): + """declaration(IfcBaseType self) -> declaration""" + return _ifcopenshell_wrapper.IfcBaseType_declaration(self) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcBaseType + __del__ = lambda self: None +IfcBaseType_swigregister = _ifcopenshell_wrapper.IfcBaseType_swigregister +IfcBaseType_swigregister(IfcBaseType) + +class parameter_type(_object): + """Proxy of C++ IfcParse::parameter_type class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, parameter_type, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, parameter_type, name) + __repr__ = _swig_repr + __swig_destroy__ = _ifcopenshell_wrapper.delete_parameter_type + __del__ = lambda self: None + + def as_named_type(self): + """as_named_type(parameter_type self) -> named_type""" + return _ifcopenshell_wrapper.parameter_type_as_named_type(self) + + + def as_simple_type(self): + """as_simple_type(parameter_type self) -> simple_type""" + return _ifcopenshell_wrapper.parameter_type_as_simple_type(self) + + + def as_aggregation_type(self): + """as_aggregation_type(parameter_type self) -> aggregation_type""" + return _ifcopenshell_wrapper.parameter_type_as_aggregation_type(self) + + + def _is(self, *args): + """ + _is(parameter_type self, std::string const & arg2) -> bool + _is(parameter_type self, declaration arg2) -> bool + """ + return _ifcopenshell_wrapper.parameter_type__is(self, *args) + + + def __init__(self): + """__init__(IfcParse::parameter_type self) -> parameter_type""" + this = _ifcopenshell_wrapper.new_parameter_type() + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this +parameter_type_swigregister = _ifcopenshell_wrapper.parameter_type_swigregister +parameter_type_swigregister(parameter_type) + +class named_type(parameter_type): + """Proxy of C++ IfcParse::named_type class.""" + + __swig_setmethods__ = {} + for _s in [parameter_type]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, named_type, name, value) + __swig_getmethods__ = {} + for _s in [parameter_type]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, named_type, name) + __repr__ = _swig_repr + + def __init__(self, declared_type): + """__init__(IfcParse::named_type self, declaration declared_type) -> named_type""" + this = _ifcopenshell_wrapper.new_named_type(declared_type) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def declared_type(self): + """declared_type(named_type self) -> declaration""" + return _ifcopenshell_wrapper.named_type_declared_type(self) + + + def as_named_type(self): + """as_named_type(named_type self) -> named_type""" + return _ifcopenshell_wrapper.named_type_as_named_type(self) + + + def _is(self, *args): + """ + _is(named_type self, std::string const & name) -> bool + _is(named_type self, declaration decl) -> bool + """ + return _ifcopenshell_wrapper.named_type__is(self, *args) + + + def __repr__(self): + return repr(self.declared_type()) + + __swig_destroy__ = _ifcopenshell_wrapper.delete_named_type + __del__ = lambda self: None +named_type_swigregister = _ifcopenshell_wrapper.named_type_swigregister +named_type_swigregister(named_type) + +class simple_type(parameter_type): + """Proxy of C++ IfcParse::simple_type class.""" + + __swig_setmethods__ = {} + for _s in [parameter_type]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, simple_type, name, value) + __swig_getmethods__ = {} + for _s in [parameter_type]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, simple_type, name) + __repr__ = _swig_repr + binary_type = _ifcopenshell_wrapper.simple_type_binary_type + boolean_type = _ifcopenshell_wrapper.simple_type_boolean_type + integer_type = _ifcopenshell_wrapper.simple_type_integer_type + logical_type = _ifcopenshell_wrapper.simple_type_logical_type + number_type = _ifcopenshell_wrapper.simple_type_number_type + real_type = _ifcopenshell_wrapper.simple_type_real_type + string_type = _ifcopenshell_wrapper.simple_type_string_type + datatype_COUNT = _ifcopenshell_wrapper.simple_type_datatype_COUNT + + def __init__(self, declared_type): + """__init__(IfcParse::simple_type self, IfcParse::simple_type::data_type declared_type) -> simple_type""" + this = _ifcopenshell_wrapper.new_simple_type(declared_type) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def declared_type(self): + """declared_type(simple_type self) -> IfcParse::simple_type::data_type""" + return _ifcopenshell_wrapper.simple_type_declared_type(self) + + + def as_simple_type(self): + """as_simple_type(simple_type self) -> simple_type""" + return _ifcopenshell_wrapper.simple_type_as_simple_type(self) + + + def __repr__(self): + return "<%s>" % self.declared_type() + + __swig_destroy__ = _ifcopenshell_wrapper.delete_simple_type + __del__ = lambda self: None +simple_type_swigregister = _ifcopenshell_wrapper.simple_type_swigregister +simple_type_swigregister(simple_type) + +class aggregation_type(parameter_type): + """Proxy of C++ IfcParse::aggregation_type class.""" + + __swig_setmethods__ = {} + for _s in [parameter_type]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, aggregation_type, name, value) + __swig_getmethods__ = {} + for _s in [parameter_type]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, aggregation_type, name) + __repr__ = _swig_repr + array_type = _ifcopenshell_wrapper.aggregation_type_array_type + bag_type = _ifcopenshell_wrapper.aggregation_type_bag_type + list_type = _ifcopenshell_wrapper.aggregation_type_list_type + set_type = _ifcopenshell_wrapper.aggregation_type_set_type + + def __init__(self, type_of_aggregation, bound1, bound2, type_of_element): + """__init__(IfcParse::aggregation_type self, IfcParse::aggregation_type::aggregate_type type_of_aggregation, int bound1, int bound2, parameter_type type_of_element) -> aggregation_type""" + this = _ifcopenshell_wrapper.new_aggregation_type(type_of_aggregation, bound1, bound2, type_of_element) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_aggregation_type + __del__ = lambda self: None + + def type_of_aggregation(self): + """type_of_aggregation(aggregation_type self) -> IfcParse::aggregation_type::aggregate_type""" + return _ifcopenshell_wrapper.aggregation_type_type_of_aggregation(self) + + + def bound1(self): + """bound1(aggregation_type self) -> int""" + return _ifcopenshell_wrapper.aggregation_type_bound1(self) + + + def bound2(self): + """bound2(aggregation_type self) -> int""" + return _ifcopenshell_wrapper.aggregation_type_bound2(self) + + + def type_of_element(self): + """type_of_element(aggregation_type self) -> parameter_type""" + return _ifcopenshell_wrapper.aggregation_type_type_of_element(self) + + + def as_aggregation_type(self): + """as_aggregation_type(aggregation_type self) -> aggregation_type""" + return _ifcopenshell_wrapper.aggregation_type_as_aggregation_type(self) + + + def type_of_aggregation_string(self): + """type_of_aggregation_string(aggregation_type self) -> std::string""" + return _ifcopenshell_wrapper.aggregation_type_type_of_aggregation_string(self) + + + def __repr__(self): + format_bound = lambda i: "?" if i == -1 else str(i) + return "<%s [%s:%s] of %r>" % ( + self.type_of_aggregation_string(), + format_bound(self.bound1()), + format_bound(self.bound2()), + self.type_of_element() + ) + +aggregation_type_swigregister = _ifcopenshell_wrapper.aggregation_type_swigregister +aggregation_type_swigregister(aggregation_type) + +class declaration(_object): + """Proxy of C++ IfcParse::declaration class.""" + + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, declaration, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, declaration, name) + __repr__ = _swig_repr + + def __init__(self, name, index_in_schema): + """__init__(IfcParse::declaration self, std::string const & name, int index_in_schema) -> declaration""" + this = _ifcopenshell_wrapper.new_declaration(name, index_in_schema) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_declaration + __del__ = lambda self: None + + def name(self): + """name(declaration self) -> std::string const &""" + return _ifcopenshell_wrapper.declaration_name(self) + + + def name_uc(self): + """name_uc(declaration self) -> std::string const &""" + return _ifcopenshell_wrapper.declaration_name_uc(self) + + + def as_type_declaration(self): + """as_type_declaration(declaration self) -> type_declaration""" + return _ifcopenshell_wrapper.declaration_as_type_declaration(self) + + + def as_select_type(self): + """as_select_type(declaration self) -> select_type""" + return _ifcopenshell_wrapper.declaration_as_select_type(self) + + + def as_enumeration_type(self): + """as_enumeration_type(declaration self) -> enumeration_type""" + return _ifcopenshell_wrapper.declaration_as_enumeration_type(self) + + + def as_entity(self): + """as_entity(declaration self) -> entity""" + return _ifcopenshell_wrapper.declaration_as_entity(self) + + + def _is(self, *args): + """ + _is(declaration self, std::string const & name) -> bool + _is(declaration self, declaration decl) -> bool + """ + return _ifcopenshell_wrapper.declaration__is(self, *args) + + + def index_in_schema(self): + """index_in_schema(declaration self) -> int""" + return _ifcopenshell_wrapper.declaration_index_in_schema(self) + + + def type(self): + """type(declaration self) -> int""" + return _ifcopenshell_wrapper.declaration_type(self) + + + def schema(self): + """schema(declaration self) -> schema_definition""" + return _ifcopenshell_wrapper.declaration_schema(self) + +declaration_swigregister = _ifcopenshell_wrapper.declaration_swigregister +declaration_swigregister(declaration) + +class type_declaration(declaration): + """Proxy of C++ IfcParse::type_declaration class.""" + + __swig_setmethods__ = {} + for _s in [declaration]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, type_declaration, name, value) + __swig_getmethods__ = {} + for _s in [declaration]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, type_declaration, name) + __repr__ = _swig_repr + + def __init__(self, name, index_in_schema, declared_type): + """__init__(IfcParse::type_declaration self, std::string const & name, int index_in_schema, parameter_type declared_type) -> type_declaration""" + this = _ifcopenshell_wrapper.new_type_declaration(name, index_in_schema, declared_type) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + __swig_destroy__ = _ifcopenshell_wrapper.delete_type_declaration + __del__ = lambda self: None + + def declared_type(self): + """declared_type(type_declaration self) -> parameter_type""" + return _ifcopenshell_wrapper.type_declaration_declared_type(self) + + + def as_type_declaration(self): + """as_type_declaration(type_declaration self) -> type_declaration""" + return _ifcopenshell_wrapper.type_declaration_as_type_declaration(self) + + + def __repr__(self): + return "" % (self.name(), self.declared_type()) + + + def argument_types(self): + """argument_types(type_declaration self) -> std::vector< std::string,std::allocator< std::string > >""" + return _ifcopenshell_wrapper.type_declaration_argument_types(self) + +type_declaration_swigregister = _ifcopenshell_wrapper.type_declaration_swigregister +type_declaration_swigregister(type_declaration) + +class select_type(declaration): + """Proxy of C++ IfcParse::select_type class.""" + + __swig_setmethods__ = {} + for _s in [declaration]: + __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) + __setattr__ = lambda self, name, value: _swig_setattr(self, select_type, name, value) + __swig_getmethods__ = {} + for _s in [declaration]: + __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) + __getattr__ = lambda self, name: _swig_getattr(self, select_type, name) + __repr__ = _swig_repr + + def __init__(self, name, index_in_schema, select_list): + """__init__(IfcParse::select_type self, std::string const & name, int index_in_schema, std::vector< IfcParse::declaration const *,std::allocator< IfcParse::declaration const * > > const & select_list) -> select_type""" + this = _ifcopenshell_wrapper.new_select_type(name, index_in_schema, select_list) + try: + self.this.append(this) + except __builtin__.Exception: + self.this = this + + def select_list(self): + """select_list(select_type self) -> std::vector< IfcParse::declaration const *,std::allocator< IfcParse::declaration const * > > const &""" + return _ifcopenshell_wrapper.select_type_select_list(self) + + + def as_select_type(self): + """as_select_type(select_type self) -> select_type""" + return _ifcopenshell_wrapper.select_type_as_select_type(self) + + + def __repr__(self): + return "